@gscdump/sdk 3.5.0 → 3.6.0

package/README.md

@@ -2,17 +2,13 @@
 
 Consumer SDK for hosted gscdump.com integrations.
 
-> The descriptor-driven HTTP client and ticketed realtime state machine are
-> exported from `@gscdump/sdk/v1`. Focused helper and compatibility clients
-> use explicit subpaths; the package root is intentionally not importable.
-> The unsafe long-lived-key realtime client was removed before v1. See the
-> [integration guide](../../docs/guides/hosted-v1.md) and
-> [v1 contract](../../docs/hosted-api-v1.md).
-
-This package is for partner applications that consume gscdump.com APIs,
-webhooks, and realtime events. Callers inject the HTTP transport and auth they
-want to use; route construction stays inside the hosted adapter. New hosted
-HTTP integrations should import the stable v1 client:
+Use `@gscdump/sdk/v1` for hosted HTTP and realtime clients.
+The package root has no export.
+Keep long-lived credentials on your server.
+
+```bash
+npm install @gscdump/sdk
+```
 
 ```ts
 import { createGscdumpV1Client } from '@gscdump/sdk/v1'
@@ -28,7 +24,7 @@ const lifecycle = await gscdump.getUserLifecycle({
 ```
 
 The v1 surface uses a server-held Bearer credential and exposes a generic
-operation executor plus typed convenience methods for all 51 registered HTTP
+operation executor plus typed convenience methods for all 55 registered HTTP
 operations across partner, analytics, and realtime.
 
 Focused guides:
@@ -59,51 +55,19 @@ const report = await gscdump.queryAnalyticsReport({
 })
 ```
 
-## Scope
-
-- Partner user lifecycle
-- Partner site lifecycle
-- Data/detail queries
-- Analysis presets
-- Sitemap and indexing reads
-- Webhook receiver contracts and HMAC verification helpers
-- Shared request/response types re-exported from `@gscdump/contracts`
-
-Analyzer Source dispatch, browser DuckDB-WASM boot, and R2 parquet attach are
-separate engine/Nuxt concerns. A Nuxt app can consume the hosted SDK through
-its own query layer; the current consumer uses `nuxt-use-query` rather than
-making the public API depend on `@gscdump/nuxt`.
-
-For v1, a Nuxt consumer keeps `user_key` and `partner_key` credentials on its
-server and exposes proxy paths that retain the upstream surface and major
-(for example `/api/gscdump/analytics/v1/...`). Browser realtime receives only
-a single-use ticket. Every semantic event's `changes[]` maps to one ordered,
-awaited query-cache effect; unsafe resync purges the whole host-owned cache
-scope and primary-reseeds it before the SDK advances its cursor or ACKs.
-
-## Boundary
-
-`@gscdump/sdk` is a consumer SDK. It must not own gscdump.com producer
-behavior.
-
-Belongs here:
+## Browser integration
 
-- request/response types and schemas for partner apps
-- route builders and pluggable HTTP clients
-- ticketed websocket client, replay/resync state, and event schemas
-- awaited realtime apply/resync hooks; a rejected effect never advances ACK
-- webhook header constants, event schemas, parsing, normalization, and signature
-  verification for receivers
+Keep `user_key` and `partner_key` credentials on your server.
+Expose a same-origin proxy that preserves the upstream surface and major version, such as `/api/gscdump/analytics/v1/...`.
+The browser receives a single-use realtime ticket.
 
-Does not belong here:
+Your `applyEvent` callback must await every cache change before the SDK advances its cursor or sends an ACK.
+Your `resync` callback must clear the affected cache scope and reload authoritative state.
+See the [realtime guide](../../docs/guides/hosted-v1.md#realtime) for the client hooks.
 
-- deciding when gscdump.com emits webhooks
-- queueing, retries, backoff, idempotency, or activity logging
-- resolving public user/site IDs from gscdump.com storage
-- generating or storing production webhook secrets
-- creating production webhook delivery IDs or envelopes
-- partner subscription filtering for outgoing deliveries
-- Durable Object stream storage, replay retention, or outbox dispatch
+The SDK provides HTTP transport, realtime state, and webhook receiver helpers.
+Your application owns authentication, caching, and UI integration.
+gscdump.com owns webhook delivery, queues, and storage.
 
 ## Webhooks
 
@@ -115,7 +79,7 @@ delivery.
 ```ts
 import { parseWebhookPayload } from '@gscdump/sdk/webhook'
 
-const envelope = await parseWebhookPayload(rawJson, {
+const envelope = await parseWebhookPayload(await request.text(), {
   secret: webhookSecret,
   signature: request.headers.get('x-gscdump-signature'),
 })

package/dist/analytics-client.d.mts

@@ -1,17 +1,17 @@
 import { AnalysisSourcesOptions, SearchTypeOptions, SourceRangeOptions } from "./hosted-query.mjs";
 import { HostedClientOptions, HostedFetch, HostedFetchOptions, HostedHeaders } from "./request.mjs";
 import { AnalysisSourcesResponse, BackfillRange, BackfillResponse, BulkFileResolutionRequest, BulkFileResolutionResponse, CountriesResponse, IndexingDiagnostics, IndexingDiagnosticsParams, IndexingInspectRateLimited, IndexingInspectRequest, IndexingInspectResponse, IndexingUrlStatus, IndexingUrlsResponse, InspectionHistoryResponse, InspectionIndex, QueryDimSourceResponse, RollupEnvelope, SearchAppearanceResponse, SiteListItem, SourceInfoOptions, SourceInfoResponse, WhoamiResponse } from "@gscdump/contracts";
-type AnalyticsFetch = HostedFetch;
-type AnalyticsHeaders = HostedHeaders;
-type AnalyticsFetchOptions = HostedFetchOptions;
-interface AnalyticsClientOptions extends HostedClientOptions {
+export type AnalyticsFetch = HostedFetch;
+export type AnalyticsHeaders = HostedHeaders;
+export type AnalyticsFetchOptions = HostedFetchOptions;
+export interface AnalyticsClientOptions extends HostedClientOptions {
   apiBase?: string;
   fetch?: AnalyticsFetch;
   headers?: AnalyticsHeaders;
   validate?: boolean | 'request' | 'response';
 }
 /** Hosted analytics transport exposed by `@gscdump/sdk`. */
-interface AnalyticsClient {
+export interface AnalyticsClient {
   whoami: () => Promise<WhoamiResponse>;
   listSites: () => Promise<SiteListItem[]>;
   getBulkSources: (params: BulkFileResolutionRequest) => Promise<BulkFileResolutionResponse>;
@@ -44,5 +44,4 @@ interface AnalyticsClient {
     end: string;
   }) => Promise<SearchAppearanceResponse>;
 }
-declare function createAnalyticsClient(options?: AnalyticsClientOptions): AnalyticsClient;
-export { AnalyticsClient, AnalyticsClientOptions, AnalyticsFetch, AnalyticsFetchOptions, AnalyticsHeaders, createAnalyticsClient };
+export declare function createAnalyticsClient(options?: AnalyticsClientOptions): AnalyticsClient;

package/dist/anonymization.d.mts

@@ -1,6 +1,5 @@
-interface DailyAnonInput {
+export interface DailyAnonInput {
   impressions: number;
   anonymizedImpressionsPct: number;
 }
-declare function weightedAnonPct(days: readonly DailyAnonInput[] | null | undefined, window?: number): number | null;
-export { DailyAnonInput, weightedAnonPct };
+export declare function weightedAnonPct(days: readonly DailyAnonInput[] | null | undefined, window?: number): number | null;

package/dist/archetype-compile.d.mts

@@ -5,8 +5,8 @@ import { ArchetypeQuery, GscSearchType, WireDateRange } from "@gscdump/contracts
  * either accepted format (SDK-branded or partner wire). Returns `null` when no
  * complete range is present.
  */
-declare function extractWireDateRange(filter: unknown): WireDateRange | null;
-interface BuilderStateToArchetypeOptions {
+export declare function extractWireDateRange(filter: unknown): WireDateRange | null;
+export interface BuilderStateToArchetypeOptions {
   searchType?: GscSearchType;
   compareRange?: WireDateRange;
 }
@@ -32,7 +32,7 @@ interface BuilderStateToArchetypeOptions {
  * hardcoded to `url, query` regardless of which two dims were requested) —
  * returns `null`.
  */
-declare function builderStateToArchetype(siteId: string, state: BuilderState, opts?: BuilderStateToArchetypeOptions): ArchetypeQuery | null;
+export declare function builderStateToArchetype(siteId: string, input: BuilderState, opts?: BuilderStateToArchetypeOptions): ArchetypeQuery | null;
 /**
  * Archetypes a hosted seam's execution wrapper can safely serve end-to-end
  * today (rows + an ACCURATE `totalCount`/`totals`, matching the legacy
@@ -44,5 +44,4 @@ declare function builderStateToArchetype(siteId: string, state: BuilderState, op
  * rather than serve a wrong `totalCount`. Revisit once the contract grows
  * those fields.
  */
-declare function archetypeSeamSupportsQuery(query: ArchetypeQuery): boolean;
-export { BuilderStateToArchetypeOptions, archetypeSeamSupportsQuery, builderStateToArchetype, extractWireDateRange };
+export declare function archetypeSeamSupportsQuery(query: ArchetypeQuery): boolean;

package/dist/archetype-compile.mjs

@@ -1,5 +1,5 @@
 import { entityDailyTimeseries, multiSeriesStackedDaily, siteDailyTimeseries, topNBreakdown, twoDimensionDetail } from "@gscdump/contracts/archetypes";
-import { extractDateRange, normalizeFilter } from "gscdump/query";
+import { extractDateRange, normalizeBuilderStateResult } from "gscdump/query";
 const KNOWN_DIMENSIONS = /* @__PURE__ */ new Set([
 	"query",
 	"queryCanonical",
@@ -41,21 +41,34 @@ function collectEqualityMatches(filter, out) {
 	return true;
 }
 function extractWireDateRange(filter) {
-	const { startDate, endDate } = extractDateRange(filter);
+	const parsed = normalizeBuilderStateResult({ filter });
+	if (!parsed.ok) return null;
+	const { startDate, endDate } = extractDateRange(parsed.value.filter);
 	return startDate && endDate ? {
 		start: startDate,
 		end: endDate
 	} : null;
 }
-function builderStateToArchetype(siteId, state, opts = {}) {
-	const range = extractWireDateRange(state.filter);
-	if (!range) return null;
+function builderStateToArchetype(siteId, input, opts = {}) {
+	const parsed = normalizeBuilderStateResult(input);
+	if (!parsed.ok) return null;
+	const state = parsed.value;
+	if (state.prefilter !== void 0 || state.dataState !== void 0 || state.aggregationType !== void 0) return null;
+	const { startDate, endDate } = extractDateRange(state.filter);
+	if (!startDate || !endDate) return null;
+	const range = {
+		start: startDate,
+		end: endDate
+	};
 	const matches = /* @__PURE__ */ new Map();
-	if (!collectEqualityMatches(normalizeFilter(state.filter), matches)) return null;
+	if (!collectEqualityMatches(state.filter, matches)) return null;
 	const dims = state.dimensions ?? [];
 	if (dims.some((d) => !KNOWN_DIMENSIONS.has(d))) return null;
 	if (dims.includes("hour") || dims.includes("searchAppearance")) return null;
-	const searchType = opts.searchType;
+	if (dims.includes("date") && (state.rowLimit !== void 0 || state.startRow !== void 0 || state.orderBy !== void 0)) return null;
+	if (state.orderBy?.column === "date") return null;
+	const searchType = opts.searchType ?? state.searchType;
+	const metrics = state.metrics;
 	const cmp = opts.compareRange;
 	const order = state.orderBy ? {
 		metric: state.orderBy.column,
@@ -72,21 +85,25 @@ function builderStateToArchetype(siteId, state, opts = {}) {
 				value: matches.get(dim)
 			}, {
 				searchType,
-				compareRange: cmp
+				compareRange: cmp,
+				metrics
 			});
 		}
 		if (matches.size > 0) return null;
 		return siteDailyTimeseries(siteId, range, {
 			searchType,
-			compareRange: cmp
+			compareRange: cmp,
+			metrics
 		});
 	}
 	if (dims.length === 2 && dims.includes("date")) {
 		if (matches.size > 0) return null;
+		if (metrics !== void 0 && metrics.length !== 1) return null;
 		const series = dims.find((d) => d !== "date");
 		return multiSeriesStackedDaily(siteId, range, series, {
 			searchType,
-			compareRange: cmp
+			compareRange: cmp,
+			metric: metrics?.[0]
 		});
 	}
 	if (dims.length === 1 && dims[0] !== "date") {
@@ -99,6 +116,7 @@ function builderStateToArchetype(siteId, state, opts = {}) {
 		}));
 		return topNBreakdown(siteId, range, primary, {
 			searchType,
+			metrics,
 			compareRange: cmp,
 			...order ? { orderBy: order } : {},
 			limit: state.rowLimit ?? 50,
@@ -107,11 +125,13 @@ function builderStateToArchetype(siteId, state, opts = {}) {
 		});
 	}
 	if (dims.length === 2 && !dims.includes("date")) {
+		if (state.startRow !== void 0 && state.startRow !== 0) return null;
 		const set = new Set(dims);
 		if (!set.has("page") || !set.has("query")) return null;
 		if (matches.size > 0) return null;
 		return twoDimensionDetail(siteId, range, {
 			searchType,
+			metrics,
 			compareRange: cmp,
 			...order ? { orderBy: order } : {},
 			...state.rowLimit ? { limit: state.rowLimit } : {}

package/dist/client.d.mts

@@ -1,10 +1,10 @@
 import { AnalysisSourcesOptions, SearchTypeOptions, SourceRangeOptions } from "./hosted-query.mjs";
 import { HostedClientOptions, HostedFetch, HostedFetchOptions, HostedHeaders } from "./request.mjs";
 import { BuilderStateWire, BulkRegisterPartnerSitesParams, BulkRegisterPartnerSitesResponse, DataDetailOptions, DataQueryOptions, GscAddAndVerifyResponse, GscVerificationRequest, GscVerificationTokenResponse, GscdumpAnalysisSourcesResponse, GscdumpAvailableSite, GscdumpDataDetailResponse, GscdumpDataResponse, GscdumpIndexingDiagnosticsResponse, GscdumpIndexingResponse, GscdumpIndexingUrlsResponse, GscdumpSiteRegistration, GscdumpSyncStatusResponse, GscdumpUserRegistration, GscdumpUserSettings, GscdumpUserSite, GscdumpUserStatus, GscdumpUserTokenUpdate, IndexingDiagnosticsParams, IndexingUrlsParams, PartnerLifecycleResponse, RegisterPartnerSiteParams, RegisterPartnerUserParams, UpdatePartnerUserTokensParams } from "@gscdump/contracts";
-type PartnerFetch = HostedFetch;
-type PartnerHeaders = HostedHeaders;
-type PartnerFetchOptions = HostedFetchOptions;
-interface PartnerClientOptions extends HostedClientOptions {
+export type PartnerFetch = HostedFetch;
+export type PartnerHeaders = HostedHeaders;
+export type PartnerFetchOptions = HostedFetchOptions;
+export interface PartnerClientOptions extends HostedClientOptions {
   /**
    * Origin API base. Use `/api` for same-origin Nitro routes, or pass a full
    * remote origin base from the host app. The client has no baked-in origin.
@@ -20,7 +20,7 @@ interface PartnerClientOptions extends HostedClientOptions {
   validate?: boolean | 'request' | 'response';
 }
 /** Hosted partner transport exposed by `@gscdump/sdk`. */
-interface PartnerClient {
+export interface PartnerClient {
   registerUser: (params: RegisterPartnerUserParams) => Promise<GscdumpUserRegistration>;
   updateUserTokens: (userId: string, params: UpdatePartnerUserTokensParams) => Promise<GscdumpUserTokenUpdate>;
   getUserStatus: (userId: string) => Promise<GscdumpUserStatus>;
@@ -56,5 +56,4 @@ interface PartnerClient {
   getUserSettings: () => Promise<GscdumpUserSettings>;
   patchUserSettings: (body: Partial<GscdumpUserSettings>) => Promise<GscdumpUserSettings>;
 }
-declare function createPartnerClient(options?: PartnerClientOptions): PartnerClient;
-export { PartnerClient, PartnerClientOptions, PartnerFetch, PartnerFetchOptions, PartnerHeaders, createPartnerClient };
+export declare function createPartnerClient(options?: PartnerClientOptions): PartnerClient;

package/dist/country-names.d.mts

@@ -1,2 +1 @@
-declare const countryName: (code: string) => string;
-export { countryName };
+export declare const countryName: (code: string) => string;

package/dist/cwv-thresholds.d.mts

@@ -1,13 +1,12 @@
-declare const CWV_GOOD_LCP = 2500;
-declare const CWV_POOR_LCP = 4000;
-declare const CWV_GOOD_INP = 200;
-declare const CWV_POOR_INP = 500;
-declare const CWV_GOOD_CLS = 0.1;
-declare const CWV_POOR_CLS = 0.25;
-type CwvBucket = 'good' | 'ni' | 'poor';
-declare function cwvBucket(metric: 'lcp' | 'inp' | 'cls', v: number): CwvBucket;
+export declare const CWV_GOOD_LCP = 2500;
+export declare const CWV_POOR_LCP = 4000;
+export declare const CWV_GOOD_INP = 200;
+export declare const CWV_POOR_INP = 500;
+export declare const CWV_GOOD_CLS = 0.1;
+export declare const CWV_POOR_CLS = 0.25;
+export type CwvBucket = 'good' | 'ni' | 'poor';
+export declare function cwvBucket(metric: 'lcp' | 'inp' | 'cls', v: number): CwvBucket;
 /** Trim long query strings for table cells / chart tooltips. */
-declare function truncateQuery(q: string, max?: number): string;
+export declare function truncateQuery(q: string, max?: number): string;
 /** Best-effort extract a hostname; returns undefined if the URL is unparseable. */
-declare function siteUrlToHostname(url: string | undefined | null): string | undefined;
-export { CWV_GOOD_CLS, CWV_GOOD_INP, CWV_GOOD_LCP, CWV_POOR_CLS, CWV_POOR_INP, CWV_POOR_LCP, CwvBucket, cwvBucket, siteUrlToHostname, truncateQuery };
+export declare function siteUrlToHostname(url: string | undefined | null): string | undefined;

package/dist/errors.d.mts

@@ -1,22 +1,21 @@
-type PartnerErrorKind = 'auth' | 'rate-limit' | 'provisioning' | 'permission' | 'network' | 'validation' | 'not-found' | 'server' | 'unknown';
-interface PartnerErrorInfo {
+export type PartnerErrorKind = 'auth' | 'rate-limit' | 'provisioning' | 'permission' | 'network' | 'validation' | 'not-found' | 'server' | 'unknown';
+export interface PartnerErrorInfo {
   kind: PartnerErrorKind;
   statusCode?: number;
   message: string;
   data?: unknown;
 }
-declare class PartnerApiError extends Error {
+export declare class PartnerApiError extends Error {
   readonly kind: PartnerErrorKind;
   readonly statusCode?: number;
   readonly data?: unknown;
   constructor(info: PartnerErrorInfo);
 }
-declare function toPartnerError(error: unknown): PartnerApiError;
+export declare function toPartnerError(error: unknown): PartnerApiError;
 /**
  * Re-raise a modelled `PartnerApiError` as itself. The error variant of every
  * `*Result` core already IS the throwable `PartnerApiError`, so the throwing
  * wrappers preserve the exact identity/message existing call sites and tests
  * assert (`rejects.toThrow(PartnerApiError)`, `toThrow('Invalid webhook signature')`).
  */
-declare function partnerErrorToException(error: PartnerApiError): PartnerApiError;
-export { PartnerApiError, PartnerErrorInfo, PartnerErrorKind, partnerErrorToException, toPartnerError };
+export declare function partnerErrorToException(error: PartnerApiError): PartnerApiError;

package/dist/errors.mjs

@@ -1,3 +1,4 @@
+import { ZodError } from "zod";
 var PartnerApiError = class extends Error {
 	kind;
 	statusCode;
@@ -12,11 +13,11 @@ var PartnerApiError = class extends Error {
 };
 function statusOf(error) {
 	const rec = error;
-	return rec.statusCode ?? rec.status ?? rec.response?.status;
+	return rec?.statusCode ?? rec?.status ?? rec?.response?.status;
 }
 function messageOf(error) {
 	const rec = error;
-	return rec.data?.message ?? rec.data?.statusMessage ?? rec.message ?? rec.statusMessage ?? String(error);
+	return rec?.data?.message ?? rec?.data?.statusMessage ?? rec?.message ?? rec?.statusMessage ?? String(error);
 }
 function kindOf(status, message) {
 	if (status === 401 || status === 403) return "auth";
@@ -31,6 +32,11 @@ function kindOf(status, message) {
 }
 function toPartnerError(error) {
 	if (error instanceof PartnerApiError) return error;
+	if (error instanceof ZodError) return new PartnerApiError({
+		kind: "validation",
+		message: error.message,
+		data: { issues: error.issues }
+	});
 	const statusCode = statusOf(error);
 	const message = messageOf(error);
 	const data = error?.data;

package/dist/gsc-console-url.d.mts

@@ -1,4 +1,4 @@
-interface GscConsoleUrlOpts {
+export interface GscConsoleUrlOpts {
   /** The GSC property — either `sc-domain:example.com` or a URL-prefix. */
   siteLabel: string;
   /** Optional page to open Performance drilldown for. */
@@ -8,5 +8,4 @@ interface GscConsoleUrlOpts {
   /** Resource: `performance`, `url-inspection`, `sitemaps`, … */
   resource?: 'performance' | 'url-inspection' | 'sitemaps' | 'index';
 }
-declare function gscConsoleUrl(opts: GscConsoleUrlOpts): string;
-export { GscConsoleUrlOpts, gscConsoleUrl };
+export declare function gscConsoleUrl(opts: GscConsoleUrlOpts): string;

package/dist/gsc-constants.d.mts

@@ -13,5 +13,4 @@
  * not unify them to a single value (gscdump plan
  * `2026-06-24-overlay-canonical-merge-unification.md` W6).
  */
-declare const GSC_STABLE_LATENCY_DAYS = 3;
-export { GSC_STABLE_LATENCY_DAYS };
+export declare const GSC_STABLE_LATENCY_DAYS = 3;

package/dist/gsc-error.d.mts

@@ -1,5 +1,5 @@
-type GscErrorStatus = 'auth-missing' | 'rate-limited' | 'network' | 'error';
-interface GscClassifiedError {
+export type GscErrorStatus = 'auth-missing' | 'rate-limited' | 'network' | 'error';
+export interface GscClassifiedError {
   status: GscErrorStatus;
   /** HTTP status code if the error came from a response, otherwise undefined. */
   code?: number;
@@ -8,5 +8,4 @@ interface GscClassifiedError {
   /** Seconds the server suggested waiting (429/503 retry payloads). */
   retryAfter?: number;
 }
-declare function classifyGscError(e: unknown): GscClassifiedError;
-export { GscClassifiedError, GscErrorStatus, classifyGscError };
+export declare function classifyGscError(e: unknown): GscClassifiedError;

package/dist/gsc-period-presets.d.mts

@@ -1,31 +1,30 @@
 import { CompareMode, Period } from "./period.mjs";
-type GscColumn = 'clicks' | 'impressions' | 'ctr' | 'position';
-interface GscColumnOption {
+export type GscColumn = 'clicks' | 'impressions' | 'ctr' | 'position';
+export interface GscColumnOption {
   key: GscColumn;
   label: string;
   icon: string;
   color: string;
 }
-interface PeriodPreset {
+export interface PeriodPreset {
   value: Period;
   label: string;
   shortLabel: string;
   group: 'rolling' | 'calendar';
 }
-declare const PERIOD_PRESETS: PeriodPreset[];
-declare const COMPARE_OPTIONS: {
+export declare const PERIOD_PRESETS: PeriodPreset[];
+export declare const COMPARE_OPTIONS: {
   value: CompareMode;
   label: string;
   description: string;
 }[];
-declare const GSC_PERIOD_OPTIONS: {
+export declare const GSC_PERIOD_OPTIONS: {
   label: string;
   value: Period;
   longLabel: string;
 }[];
-declare const GSC_PERIOD_OPTIONS_LONG: {
+export declare const GSC_PERIOD_OPTIONS_LONG: {
   label: string;
   value: Period;
 }[];
-declare const GSC_COLUMN_OPTIONS: GscColumnOption[];
-export { COMPARE_OPTIONS, GSC_COLUMN_OPTIONS, GSC_PERIOD_OPTIONS, GSC_PERIOD_OPTIONS_LONG, GscColumn, GscColumnOption, PERIOD_PRESETS, PeriodPreset };
+export declare const GSC_COLUMN_OPTIONS: GscColumnOption[];

package/dist/gsc-rows.d.mts

@@ -1,23 +1,23 @@
-interface RawDailyRow {
+export interface RawDailyRow {
   date: string;
   clicks: number;
   impressions: number;
   sum_position?: number;
   position?: number;
 }
-interface CanonicalDailyRow {
+export interface CanonicalDailyRow {
   date: string;
   clicks: number;
   impressions: number;
   sum_position: number;
 }
-interface GscRowTotals {
+export interface GscRowTotals {
   clicks: number;
   impressions: number;
   ctr: number;
   position: number;
 }
-interface GscDailySummary {
+export interface GscDailySummary {
   daily: CanonicalDailyRow[];
   totals: GscRowTotals;
   chartData: Array<{
@@ -32,7 +32,7 @@ interface GscDailySummary {
  * sentinel — the old `Math.max(1, …)` clamp synthesized rank #1 (sum 0 with
  * full impression weight) for such rows instead of contributing nothing.
  */
-declare function coerceRowMetrics<T extends {
+export declare function coerceRowMetrics<T extends {
   impressions: number;
   sum_position?: number;
   position?: number;
@@ -40,15 +40,14 @@ declare function coerceRowMetrics<T extends {
   sum_position: number;
 };
 /** Sort daily rows by date asc, coerce `sum_position`, reduce totals, derive chartData. */
-declare function summarizeDailyRows(raw: readonly RawDailyRow[]): GscDailySummary;
+export declare function summarizeDailyRows(raw: readonly RawDailyRow[]): GscDailySummary;
 /**
  * Rollup-row position helper. `sum_position` is GSC's average-position sum
  * across impressions; dividing back out (+1 because GSC is 1-indexed) gives
  * the impression-weighted average position. Returns 0 when there were no
  * impressions so the column renders blank rather than NaN.
  */
-declare function positionFor(r: {
+export declare function positionFor(r: {
   impressions: number;
   sum_position: number;
-}): number;
-export { CanonicalDailyRow, GscDailySummary, GscRowTotals, RawDailyRow, coerceRowMetrics, positionFor, summarizeDailyRows };
+}): number;

package/dist/hosted-query.d.mts

@@ -1,27 +1,27 @@
 import { BuilderStateWire, DataDetailOptions, DataQueryOptions, IndexingDiagnosticsParams, IndexingUrlsParams, SourceInfoOptions } from "@gscdump/contracts";
 import { GscSearchType, GscSearchType as GscSearchType$2 } from "@gscdump/contracts/search-types";
-interface SearchTypeOptions {
+export interface SearchTypeOptions {
   searchType?: GscSearchType$2;
 }
-interface SourceRangeOptions {
+export interface SourceRangeOptions {
   start?: string;
   end?: string;
   startDate?: string;
   endDate?: string;
 }
-interface AnalysisSourcesOptions extends SearchTypeOptions, SourceRangeOptions {
+export interface AnalysisSourcesOptions extends SearchTypeOptions, SourceRangeOptions {
   tables?: string[] | string;
   maxBytes?: number;
   maxRows?: number;
   maxFiles?: number;
 }
-declare const DEFAULT_SEARCH_TYPE: GscSearchType$2;
-declare function withDefaultSearchType<T extends object>(value: T, searchType?: GscSearchType$2): T & SearchTypeOptions & Record<string, unknown>;
-declare function withDefaultSearchType<T>(value: T, searchType?: GscSearchType$2): T;
-declare function sourceInfoQuery(options: SourceInfoOptions | undefined): Record<string, string>;
-declare function tablesQuery(tablesOrOptions: string[] | string | AnalysisSourcesOptions | undefined, options?: AnalysisSourcesOptions): Record<string, string>;
-declare function dataQuery(state: BuilderStateWire, options?: DataQueryOptions): Record<string, string>;
-declare function dataDetailQuery(state: BuilderStateWire, options?: DataDetailOptions): Record<string, string>;
-declare function indexingUrlsQuery(params?: IndexingUrlsParams): Record<string, string | number>;
-declare function indexingDiagnosticsQuery(params?: IndexingDiagnosticsParams): Record<string, string | number>;
-export { AnalysisSourcesOptions, DEFAULT_SEARCH_TYPE, type GscSearchType, SearchTypeOptions, SourceRangeOptions, dataDetailQuery, dataQuery, indexingDiagnosticsQuery, indexingUrlsQuery, sourceInfoQuery, tablesQuery, withDefaultSearchType };
+export declare const DEFAULT_SEARCH_TYPE: GscSearchType$2;
+export declare function withDefaultSearchType<T extends object>(value: T, searchType?: GscSearchType$2): T & SearchTypeOptions & Record<string, unknown>;
+export declare function withDefaultSearchType<T>(value: T, searchType?: GscSearchType$2): T;
+export declare function sourceInfoQuery(options: SourceInfoOptions | undefined): Record<string, string>;
+export declare function tablesQuery(tablesOrOptions: string[] | string | AnalysisSourcesOptions | undefined, options?: AnalysisSourcesOptions): Record<string, string>;
+export declare function dataQuery(state: BuilderStateWire, options?: DataQueryOptions): Record<string, string>;
+export declare function dataDetailQuery(state: BuilderStateWire, options?: DataDetailOptions): Record<string, string>;
+export declare function indexingUrlsQuery(params?: IndexingUrlsParams): Record<string, string | number>;
+export declare function indexingDiagnosticsQuery(params?: IndexingDiagnosticsParams): Record<string, string | number>;
+export type { GscSearchType };

package/dist/indexing-issues.d.mts

@@ -1,9 +1,9 @@
-interface IndexingIssueDetail {
+export interface IndexingIssueDetail {
   description: string;
   fix: string;
 }
-type IssueSeverity = 'error' | 'warning' | 'info';
-interface IndexingIssue {
+export type IssueSeverity = 'error' | 'warning' | 'info';
+export interface IndexingIssue {
   type: string;
   label: string;
   severity: IssueSeverity;
@@ -11,9 +11,9 @@ interface IndexingIssue {
   description: string;
   fix: string;
 }
-declare const issueDetails: Record<string, IndexingIssueDetail>;
-declare const severityOrder: IssueSeverity[];
-interface IssueGroup {
+export declare const issueDetails: Record<string, IndexingIssueDetail>;
+export declare const severityOrder: IssueSeverity[];
+export interface IssueGroup {
   id: string;
   label: string;
   icon: string;
@@ -27,5 +27,4 @@ interface IssueGroup {
   /** Issue types belonging to this group */
   issueTypes: string[];
 }
-declare const issueGroups: IssueGroup[];
-export { IndexingIssue, IndexingIssueDetail, IssueGroup, IssueSeverity, issueDetails, issueGroups, severityOrder };
+export declare const issueGroups: IssueGroup[];

package/dist/lifecycle.d.mts

@@ -4,10 +4,9 @@ import { GscdumpSyncStatusResponse, GscdumpUserSite, PartnerLifecycleSite } from
  * Keeping the adapters structural lets consumers migrate to v1 without
  * re-introducing legacy-only fields such as `intId` or `lifecycleRevision`.
  */
-type LifecycleSiteLike = Pick<PartnerLifecycleSite, 'siteId' | 'externalSiteId' | 'requestedUrl' | 'gscPropertyUrl' | 'permissionLevel' | 'analytics' | 'indexing' | 'latestError' | 'updatedAt'>;
-declare function analyticsStatusToSyncStatus(status: LifecycleSiteLike['analytics']['status']): GscdumpUserSite['syncStatus'];
-declare function lifecycleSiteToSyncStatus(site: LifecycleSiteLike): GscdumpSyncStatusResponse;
-declare function findLifecycleSite<TSite extends LifecycleSiteLike>(lifecycle: {
+export type LifecycleSiteLike = Pick<PartnerLifecycleSite, 'siteId' | 'externalSiteId' | 'requestedUrl' | 'gscPropertyUrl' | 'permissionLevel' | 'analytics' | 'indexing' | 'latestError' | 'updatedAt'>;
+export declare function analyticsStatusToSyncStatus(status: LifecycleSiteLike['analytics']['status']): GscdumpUserSite['syncStatus'];
+export declare function lifecycleSiteToSyncStatus(site: LifecycleSiteLike): GscdumpSyncStatusResponse;
+export declare function findLifecycleSite<TSite extends LifecycleSiteLike>(lifecycle: {
   sites: readonly TSite[];
-}, siteIdOrPropertyUrl: string): TSite | null;
-export { LifecycleSiteLike, analyticsStatusToSyncStatus, findLifecycleSite, lifecycleSiteToSyncStatus };
+}, siteIdOrPropertyUrl: string): TSite | null;

package/dist/period.d.mts

@@ -1,14 +1,14 @@
-type RollingPeriod = '7d' | '28d' | '3m' | '6m' | '12m';
-type CalendarPeriod = 'this-week' | 'this-month' | 'last-month' | 'this-quarter' | 'this-year';
+export type RollingPeriod = '7d' | '28d' | '3m' | '6m' | '12m';
+export type CalendarPeriod = 'this-week' | 'this-month' | 'last-month' | 'this-quarter' | 'this-year';
 /**
  * Custom date range from drag-to-zoom.
  *  - `custom:CS:CE` - current range only; prev range resolved by compareMode.
  *  - `custom:CS:CE:PS:PE` - explicit prev range.
  */
-type CustomPeriod = `custom:${string}:${string}` | `custom:${string}:${string}:${string}:${string}`;
-type Period = RollingPeriod | CalendarPeriod | CustomPeriod;
-type CompareMode = 'previous' | 'year' | 'none';
-interface DateRangeResult {
+export type CustomPeriod = `custom:${string}:${string}` | `custom:${string}:${string}:${string}:${string}`;
+export type Period = RollingPeriod | CalendarPeriod | CustomPeriod;
+export type CompareMode = 'previous' | 'year' | 'none';
+export interface DateRangeResult {
   start: string;
   end: string;
   prevStart: string;
@@ -17,7 +17,7 @@ interface DateRangeResult {
   yearEnd: string;
   days: number;
 }
-interface PeriodOptions {
+export interface PeriodOptions {
   /** Subtract GSC's stable-data latency from `end`. Default `true`. */
   stableData?: boolean;
   /** IANA timezone used to resolve today's calendar date. Default GSC/Pacific time. */
@@ -25,16 +25,16 @@ interface PeriodOptions {
   /** Clock used to resolve today's calendar date. Defaults to the current time. */
   now?: Date;
 }
-declare function isCustomPeriod(p: Period | string): p is CustomPeriod;
-declare function parseCustomPeriod(p: Period | string): {
+export declare function isCustomPeriod(p: Period | string): p is CustomPeriod;
+export declare function parseCustomPeriod(p: Period | string): {
   start: string;
   end: string;
   prevStart?: string;
   prevEnd?: string;
 } | null;
-declare function periodToDateRange(period: Period | string, stableDataOrOptions?: boolean | PeriodOptions): DateRangeResult;
-declare function periodToDays(period: Period | string, stableDataOrOptions?: boolean | PeriodOptions): number;
-declare function compareRange(range: DateRangeResult, mode: CompareMode): {
+export declare function periodToDateRange(period: Period | string, stableDataOrOptions?: boolean | PeriodOptions): DateRangeResult;
+export declare function periodToDays(period: Period | string, stableDataOrOptions?: boolean | PeriodOptions): number;
+export declare function compareRange(range: DateRangeResult, mode: CompareMode): {
   start: string;
   end: string;
 } | null;
@@ -45,5 +45,4 @@ declare function compareRange(range: DateRangeResult, mode: CompareMode): {
  *
  * Uses YYYY-MM-DD string math directly to avoid UTC/local timezone shifts.
  */
-declare function getGscUnstableCutoffDate(): string;
-export { CalendarPeriod, CompareMode, CustomPeriod, DateRangeResult, Period, PeriodOptions, RollingPeriod, compareRange, getGscUnstableCutoffDate, isCustomPeriod, parseCustomPeriod, periodToDateRange, periodToDays };
+export declare function getGscUnstableCutoffDate(): string;

package/dist/request.d.mts

@@ -1,9 +1,9 @@
 import { PartnerApiError } from "./errors.mjs";
 import { Result } from "gscdump/result";
 import { ZodTypeAny } from "zod";
-type HostedFetch = <T = unknown>(request: string, options?: HostedFetchOptions) => Promise<T>;
-type HostedHeaders = HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
-interface HostedFetchOptions {
+export type HostedFetch = <T = unknown>(request: string, options?: HostedFetchOptions) => Promise<T>;
+export type HostedHeaders = HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+export interface HostedFetchOptions {
   method?: string;
   headers?: HeadersInit;
   query?: Record<string, unknown>;
@@ -12,7 +12,7 @@ interface HostedFetchOptions {
   dedupe?: boolean;
   [key: string]: unknown;
 }
-interface HostedClientOptions {
+export interface HostedClientOptions {
   apiBase?: string;
   fetch?: HostedFetch;
   headers?: HostedHeaders;
@@ -21,5 +21,4 @@ interface HostedClientOptions {
   dedupe?: boolean;
   /** Optional shared in-flight map for de-duping across related client instances. */
   dedupeScope?: Map<string, Promise<Result<unknown, PartnerApiError>>>;
-}
-export { HostedClientOptions, HostedFetch, HostedFetchOptions, HostedHeaders };
+}

package/dist/search-console-stage.d.mts

@@ -1,11 +1,11 @@
-type SearchConsoleStageKey = 'not_connected' | 'waiting_for_data' | 'weak_discovery' | 'discovery_backlog' | 'crawl_blocked' | 'indexability_blocked' | 'index_rejection' | 'partially_indexed' | 'indexed_invisible' | 'visible_not_clicked' | 'ranking_stalled' | 'declining_visibility' | 'healthy_growth_ready';
-type SearchConsoleStageSeverity = 'success' | 'error' | 'warning' | 'info' | 'neutral';
-interface SearchConsoleStageEvidence {
+export type SearchConsoleStageKey = 'not_connected' | 'waiting_for_data' | 'weak_discovery' | 'discovery_backlog' | 'crawl_blocked' | 'indexability_blocked' | 'index_rejection' | 'partially_indexed' | 'indexed_invisible' | 'visible_not_clicked' | 'ranking_stalled' | 'declining_visibility' | 'healthy_growth_ready';
+export type SearchConsoleStageSeverity = 'success' | 'error' | 'warning' | 'info' | 'neutral';
+export interface SearchConsoleStageEvidence {
   label: string;
   value: string;
   source: 'connection' | 'indexing' | 'sitemap' | 'performance' | 'inspection' | 'canonical';
 }
-interface SearchConsoleStage {
+export interface SearchConsoleStage {
   key: SearchConsoleStageKey;
   label: string;
   severity: SearchConsoleStageSeverity;
@@ -15,13 +15,13 @@ interface SearchConsoleStage {
   evidence: SearchConsoleStageEvidence[];
   sprintFindingTypes: string[];
 }
-interface SearchConsoleStageIssue {
+export interface SearchConsoleStageIssue {
   type: string;
   label: string;
   severity?: 'error' | 'warning' | 'info';
   count: number;
 }
-interface SearchConsoleStageSummary {
+export interface SearchConsoleStageSummary {
   totalUrls: number;
   indexed: number;
   indexedPercent: number;
@@ -37,7 +37,7 @@ interface SearchConsoleStageSummary {
  * days before computing these, and the 7-day window is intentionally absent —
  * it is too lag-contaminated to classify on.
  */
-interface SearchConsoleStageTrajectory {
+export interface SearchConsoleStageTrajectory {
   clicksPct90d?: number | null;
   impressionsPct90d?: number | null;
   positionDelta90d?: number | null;
@@ -49,18 +49,18 @@ interface SearchConsoleStageTrajectory {
    */
   clicksPrior28d?: number | null;
 }
-interface SearchConsoleStageSitemap {
+export interface SearchConsoleStageSitemap {
   errors?: number | null;
   warnings?: number | null;
   lastError?: string | null;
   urlCount?: number | null;
 }
-interface SearchConsoleStagePage {
+export interface SearchConsoleStagePage {
   impressions: number;
   clicks: number;
   position?: number | null;
 }
-interface ClassifySearchConsoleStageInput {
+export interface ClassifySearchConsoleStageInput {
   connected: boolean;
   indexingStatus?: 'pending' | 'partial' | 'complete' | 'unknown' | string | null;
   summary?: SearchConsoleStageSummary | null;
@@ -95,5 +95,4 @@ interface ClassifySearchConsoleStageInput {
  * v2 classifier. Direct indexing evidence remains actionable at any traffic
  * volume. Comparative reach claims require enough current observations.
  */
-declare function classifySearchConsoleStage(input: ClassifySearchConsoleStageInput): SearchConsoleStage;
-export { ClassifySearchConsoleStageInput, SearchConsoleStage, SearchConsoleStageEvidence, SearchConsoleStageIssue, SearchConsoleStageKey, SearchConsoleStagePage, SearchConsoleStageSeverity, SearchConsoleStageSitemap, SearchConsoleStageSummary, SearchConsoleStageTrajectory, classifySearchConsoleStage };
+export declare function classifySearchConsoleStage(input: ClassifySearchConsoleStageInput): SearchConsoleStage;

package/dist/site-baseline.d.mts

@@ -1,12 +1,12 @@
-type SiteType = 'saas' | 'ecommerce' | 'docs' | 'blog' | 'agency' | 'portfolio' | 'other';
+export type SiteType = 'saas' | 'ecommerce' | 'docs' | 'blog' | 'agency' | 'portfolio' | 'other';
 /**
  * Normalise the AI profile `type` to the closed enum. The categoriser mostly
  * emits the 7 values but occasionally leaks free-text (e.g. "event") or null
  * (~40% of live sites are unprofiled) — everything unknown collapses to `other`
  * so downstream logic always has a defined bucket.
  */
-declare function normalizeSiteType(raw: string | null | undefined): SiteType;
-interface SiteTypeBaseline {
+export declare function normalizeSiteType(raw: string | null | undefined): SiteType;
+export interface SiteTypeBaseline {
   label: string;
   /**
    * Whether indexed-coverage% is a meaningful health signal for this type.
@@ -24,10 +24,10 @@ interface SiteTypeBaseline {
   /** The default growth lever when the site is healthy and leading. */
   primaryGoal: 'content' | 'authority' | 'conversion' | 'coverage';
 }
-declare function siteTypeBaseline(raw: string | null | undefined): SiteTypeBaseline;
-type PeerStanding = 'leader' | 'on_par' | 'behind' | 'unknown';
+export declare function siteTypeBaseline(raw: string | null | undefined): SiteTypeBaseline;
+export type PeerStanding = 'leader' | 'on_par' | 'behind' | 'unknown';
 /** How much to trust the standing: a median over 1–2 peers is noisy. */
-type PeerConfidence = 'high' | 'low' | 'none';
+export type PeerConfidence = 'high' | 'low' | 'none';
 /**
  * Peer metrics from tracked competitors (`siteCompetitors`). Domain rank is the
  * DataForSEO-derived 0–100 score (`min(100, log10(keywordCount)*20)`), NOT a
@@ -35,13 +35,13 @@ type PeerConfidence = 'high' | 'low' | 'none';
  * The site's OWN metrics are not stored alongside competitors, so callers must
  * supply them (one cheap cached `estimateDomainTraffic` call).
  */
-interface PeerBaselineInput {
+export interface PeerBaselineInput {
   siteDomainRank?: number | null;
   siteOrganicTraffic?: number | null;
   competitorDomainRanks?: number[] | null;
   competitorOrganicTraffic?: number[] | null;
 }
-interface SiteBaseline {
+export interface SiteBaseline {
   siteType: SiteType;
   baseline: SiteTypeBaseline;
   peerStanding: PeerStanding;
@@ -53,7 +53,7 @@ interface SiteBaseline {
   goalKind: SiteTypeBaseline['primaryGoal'];
 }
 /** Standing is decided on domain rank first; organic traffic breaks the tie. */
-declare function derivePeerStanding(input: PeerBaselineInput): {
+export declare function derivePeerStanding(input: PeerBaselineInput): {
   standing: PeerStanding;
   confidence: PeerConfidence;
   peerMedianDomainRank: number | null;
@@ -64,5 +64,4 @@ declare function derivePeerStanding(input: PeerBaselineInput): {
  * defends and expands on its type's lever; a site that's behind closes the gap
  * on the same lever; unknown standing falls back to the type default.
  */
-declare function deriveSiteBaseline(rawType: string | null | undefined, peer?: PeerBaselineInput): SiteBaseline;
-export { PeerBaselineInput, PeerConfidence, PeerStanding, SiteBaseline, SiteType, SiteTypeBaseline, derivePeerStanding, deriveSiteBaseline, normalizeSiteType, siteTypeBaseline };
+export declare function deriveSiteBaseline(rawType: string | null | undefined, peer?: PeerBaselineInput): SiteBaseline;

package/dist/site-triage.d.mts

@@ -1,7 +1,7 @@
 import { SearchConsoleStageIssue } from "./search-console-stage.mjs";
-type ReachStage = 'emerging' | 'growing' | 'plateaued' | 'declining' | 'faded' | 'decayed';
-type HealthStage = 'healthy' | 'crawl_faults' | 'quality_rejection';
-interface TriageEvidence {
+export type ReachStage = 'emerging' | 'growing' | 'plateaued' | 'declining' | 'faded' | 'decayed';
+export type HealthStage = 'healthy' | 'crawl_faults' | 'quality_rejection';
+export interface TriageEvidence {
   label: string;
   value: string;
 }
@@ -16,7 +16,7 @@ interface TriageEvidence {
  *
  * `gapLabel` is always a concrete count (pages/clicks/points), never a bare %.
  */
-interface StageProgression {
+export interface StageProgression {
   nextStage: ReachStage | HealthStage | null;
   metric: string;
   value: number;
@@ -25,27 +25,27 @@ interface StageProgression {
   gapLabel: string;
   direction: 'advance' | 'escape' | 'sustain';
 }
-interface ReachVerdict {
+export interface ReachVerdict {
   stage: ReachStage;
   summary: string;
   primaryAction: string;
   evidence: TriageEvidence[];
   progression: StageProgression;
 }
-interface HealthVerdict {
+export interface HealthVerdict {
   stage: HealthStage;
   summary: string;
   primaryAction: string;
   evidence: TriageEvidence[];
   progression: StageProgression;
 }
-interface SiteTriage {
+export interface SiteTriage {
   reach: ReachVerdict;
   health: HealthVerdict;
   /** Which axis leads the dashboard headline. */
   headline: 'reach' | 'health';
 }
-interface SiteTriageInput {
+export interface SiteTriageInput {
   /** Impressions over the trailing 28 days — the maturity tier. */
   impressions28d?: number | null;
   /** Lifetime-ish impressions (trailing 12 months) — separates new from decayed/faded. */
@@ -76,10 +76,9 @@ interface SiteTriageInput {
  * (GSC reporting lag) are trimmed before the latest-week sum. Returns null when
  * the series is too short to judge.
  */
-declare function reachLivenessRatio(daily: Array<{
+export declare function reachLivenessRatio(daily: Array<{
   impressions: number;
 }> | null | undefined): number | null;
-declare function classifyHealthStage(input: SiteTriageInput): HealthVerdict;
-declare function classifyReachStage(input: SiteTriageInput): ReachVerdict;
-declare function classifySiteTriage(input: SiteTriageInput): SiteTriage;
-export { HealthStage, HealthVerdict, ReachStage, ReachVerdict, SiteTriage, SiteTriageInput, StageProgression, TriageEvidence, classifyHealthStage, classifyReachStage, classifySiteTriage, reachLivenessRatio };
+export declare function classifyHealthStage(input: SiteTriageInput): HealthVerdict;
+export declare function classifyReachStage(input: SiteTriageInput): ReachVerdict;
+export declare function classifySiteTriage(input: SiteTriageInput): SiteTriage;

package/dist/v1/http.d.mts

@@ -15,8 +15,8 @@ interface GscdumpV1ClientMethodAliases {
 type GscdumpV1ClientMethodFor<TMethod extends GscdumpV1RegistryMethodName> = TMethod extends keyof GscdumpV1ClientMethodAliases ? GscdumpV1ClientMethodAliases[TMethod] : TMethod;
 type GscdumpV1NamedOperations = { [TMethod in GscdumpV1RegistryMethodName as GscdumpV1ClientMethodFor<TMethod>]: GscdumpV1RegistryOperations[TMethod]; };
 type GscdumpV1ClientMethodName = keyof GscdumpV1NamedOperations & string;
-type GscdumpV1Operation = GscdumpV1Operation$1;
-type GscdumpV1OperationId = GscdumpV1OperationId$1;
+export type GscdumpV1Operation = GscdumpV1Operation$1;
+export type GscdumpV1OperationId = GscdumpV1OperationId$1;
 type OperationById<TId extends GscdumpV1OperationId> = Extract<GscdumpV1Operation, {
   id: TId;
 }>;
@@ -24,14 +24,14 @@ type SchemaInput<TSchema> = TSchema extends ZodTypeAny ? z.input<TSchema> : neve
 type SchemaOutput<TSchema> = TSchema extends ZodTypeAny ? z.output<TSchema> : never;
 type RequiredLocation<TKey extends string, TSchema> = TSchema extends ZodTypeAny ? { [K in TKey]: SchemaInput<TSchema>; } : { [K in TKey]?: never; };
 type OptionalLocation<TKey extends string, TSchema> = TSchema extends ZodTypeAny ? { [K in TKey]?: SchemaInput<TSchema>; } : { [K in TKey]?: never; };
-type GscdumpV1OperationInput<TId extends GscdumpV1OperationId> = RequiredLocation<'params', OperationById<TId>['request']['params']> & RequiredLocation<'query', OperationById<TId>['request']['query']> & OptionalLocation<'headers', OperationById<TId>['request']['headers']> & RequiredLocation<'body', OperationById<TId>['request']['body']>;
+export type GscdumpV1OperationInput<TId extends GscdumpV1OperationId> = RequiredLocation<'params', OperationById<TId>['request']['params']> & RequiredLocation<'query', OperationById<TId>['request']['query']> & OptionalLocation<'headers', OperationById<TId>['request']['headers']> & RequiredLocation<'body', OperationById<TId>['request']['body']>;
 type OperationResponseSchema<TId extends GscdumpV1OperationId> = ValueOf<OperationById<TId>['responses']> extends (infer TResponse) ? TResponse extends {
   client: infer TClient extends ZodTypeAny;
 } ? TClient : never : never;
-type GscdumpV1OperationResponse<TId extends GscdumpV1OperationId> = SchemaOutput<OperationResponseSchema<TId>>;
-type GscdumpV1CredentialResolver = string | (() => MaybePromise<string>);
-type GscdumpV1HeadersResolver = HeadersInit | (() => MaybePromise<HeadersInit>);
-interface GscdumpV1RetryOptions {
+export type GscdumpV1OperationResponse<TId extends GscdumpV1OperationId> = SchemaOutput<OperationResponseSchema<TId>>;
+export type GscdumpV1CredentialResolver = string | (() => MaybePromise<string>);
+export type GscdumpV1HeadersResolver = HeadersInit | (() => MaybePromise<HeadersInit>);
+export interface GscdumpV1RetryOptions {
   /** Total attempts, including the initial request. Defaults to 3 and is capped at 5. */
   maxAttempts?: number;
   /** Deterministic exponential-backoff base. Defaults to 250 ms. */
@@ -39,7 +39,7 @@ interface GscdumpV1RetryOptions {
   /** Backoff ceiling. Defaults to 2 seconds. Retry-After can exceed this ceiling. */
   maxDelayMs?: number;
 }
-interface CreateGscdumpV1ClientOptions {
+export interface CreateGscdumpV1ClientOptions {
   /**
    * Root replacing the contract's `/api` segment. Direct calls default to
    * `https://gscdump.com/api`; a same-origin proxy can use `/api/_gscdump`.
@@ -50,13 +50,13 @@ interface CreateGscdumpV1ClientOptions {
   headers?: GscdumpV1HeadersResolver;
   retry?: GscdumpV1RetryOptions;
 }
-interface GscdumpV1ExecuteOptions {
+export interface GscdumpV1ExecuteOptions {
   signal?: AbortSignal;
   requestId?: string;
   idempotencyKey?: string;
 }
-type GscdumpV1SdkErrorCode = GscdumpV1ErrorEnvelope['error']['code'] | 'aborted' | 'credential_resolution' | 'network_error' | 'protocol_error' | 'request_validation' | 'response_validation';
-interface GscdumpV1ErrorOptions {
+export type GscdumpV1SdkErrorCode = GscdumpV1ErrorEnvelope['error']['code'] | 'aborted' | 'credential_resolution' | 'network_error' | 'protocol_error' | 'request_validation' | 'response_validation';
+export interface GscdumpV1ErrorOptions {
   code: GscdumpV1SdkErrorCode;
   message: string;
   status?: number;
@@ -66,7 +66,7 @@ interface GscdumpV1ErrorOptions {
   cause?: unknown;
 }
 /** One stable, tagged failure shape for validation, transport, and API errors. */
-declare class GscdumpV1Error extends Error {
+export declare class GscdumpV1Error extends Error {
   readonly tag: "GscdumpV1Error";
   readonly code: GscdumpV1SdkErrorCode;
   readonly status?: number;
@@ -76,14 +76,13 @@ declare class GscdumpV1Error extends Error {
   readonly cause?: unknown;
   constructor(options: GscdumpV1ErrorOptions);
 }
-declare function isGscdumpV1Error(error: unknown): error is GscdumpV1Error;
+export declare function isGscdumpV1Error(error: unknown): error is GscdumpV1Error;
 type MethodId<TMethod extends GscdumpV1ClientMethodName> = GscdumpV1NamedOperations[TMethod] extends {
   id: infer TId extends GscdumpV1OperationId;
 } ? TId : never;
 type GscdumpV1OperationMethod<TId extends GscdumpV1OperationId> = Record<never, never> extends GscdumpV1OperationInput<TId> ? (input?: GscdumpV1OperationInput<TId>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<TId>> : (input: GscdumpV1OperationInput<TId>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<TId>>;
-type GscdumpV1Client = {
+export type GscdumpV1Client = {
   execute: <TId extends GscdumpV1OperationId>(operation: TId, input: NoInfer<GscdumpV1OperationInput<TId>>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<TId>>;
 } & { [TMethod in GscdumpV1ClientMethodName]: GscdumpV1OperationMethod<MethodId<TMethod>>; };
 /** Create one framework-neutral client whose behavior is driven by the v1 registry. */
-declare function createGscdumpV1Client(options: CreateGscdumpV1ClientOptions): GscdumpV1Client;
-export { CreateGscdumpV1ClientOptions, GscdumpV1Client, GscdumpV1CredentialResolver, GscdumpV1Error, GscdumpV1ErrorOptions, GscdumpV1ExecuteOptions, GscdumpV1HeadersResolver, GscdumpV1Operation, GscdumpV1OperationId, GscdumpV1OperationInput, GscdumpV1OperationResponse, GscdumpV1RetryOptions, GscdumpV1SdkErrorCode, createGscdumpV1Client, isGscdumpV1Error };
+export declare function createGscdumpV1Client(options: CreateGscdumpV1ClientOptions): GscdumpV1Client;

package/dist/v1/realtime.d.mts

@@ -1,10 +1,10 @@
 import { RealtimeV1Cursor, RealtimeV1Event, RealtimeV1StreamHead, RealtimeV1StreamId } from "@gscdump/contracts/v1/realtime";
 type MaybePromise<T> = T | Promise<T>;
-declare const GSCDUMP_REALTIME_V1_SDK_VERSION: "3.5.0";
-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';
-interface GscdumpRealtimeV1ErrorOptions {
+export declare const GSCDUMP_REALTIME_V1_SDK_VERSION: "3.6.0";
+export type GscdumpRealtimeV1TransportState = 'idle' | 'ticketing' | 'connecting' | 'handshaking' | 'replaying' | 'live' | 'waiting' | 'stopped' | 'terminal';
+export type GscdumpRealtimeV1Freshness = 'unknown' | 'stale' | 'applying' | 'fresh' | 'resyncing' | 'degraded';
+export 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';
+export interface GscdumpRealtimeV1ErrorOptions {
   code: GscdumpRealtimeV1ErrorCode;
   message: string;
   retryable: boolean;
@@ -12,7 +12,7 @@ interface GscdumpRealtimeV1ErrorOptions {
   details?: Record<string, unknown>;
   cause?: unknown;
 }
-declare class GscdumpRealtimeV1Error extends Error {
+export declare class GscdumpRealtimeV1Error extends Error {
   readonly tag: "GscdumpRealtimeV1Error";
   readonly code: GscdumpRealtimeV1ErrorCode;
   readonly retryable: boolean;
@@ -21,11 +21,11 @@ declare class GscdumpRealtimeV1Error extends Error {
   readonly cause?: unknown;
   constructor(options: GscdumpRealtimeV1ErrorOptions);
 }
-interface GscdumpRealtimeV1CursorStore {
+export interface GscdumpRealtimeV1CursorStore {
   load: () => MaybePromise<RealtimeV1Cursor | null>;
   save: (cursor: RealtimeV1Cursor) => MaybePromise<void>;
 }
-interface GscdumpRealtimeV1SocketLike {
+export interface GscdumpRealtimeV1SocketLike {
   readonly readyState: number;
   readonly protocol: string;
   onopen: ((event: unknown) => void) | null;
@@ -41,15 +41,15 @@ interface GscdumpRealtimeV1SocketLike {
   send: (data: string) => void;
   close: (code?: number, reason?: string) => void;
 }
-interface GscdumpRealtimeV1Runtime {
+export interface GscdumpRealtimeV1Runtime {
   createSocket: (url: string, protocols: readonly string[]) => GscdumpRealtimeV1SocketLike;
   setTimeout: (handler: () => void, ms: number) => unknown;
   clearTimeout: (handle: unknown) => void;
   random: () => number;
   now: () => number;
 }
-type GscdumpRealtimeV1ResyncReason = 'cursor_expired' | 'retention_gap' | 'sequence_gap' | 'stream_mismatch' | 'initial_cursor_missing' | 'effect_application_failed';
-interface GscdumpRealtimeV1ResyncRequest {
+export type GscdumpRealtimeV1ResyncReason = 'cursor_expired' | 'retention_gap' | 'sequence_gap' | 'stream_mismatch' | 'initial_cursor_missing' | 'effect_application_failed';
+export interface GscdumpRealtimeV1ResyncRequest {
   reason: GscdumpRealtimeV1ResyncReason;
   source: 'server' | 'client';
   streamId: RealtimeV1StreamId;
@@ -58,7 +58,7 @@ interface GscdumpRealtimeV1ResyncRequest {
   failedEvent?: RealtimeV1Event;
   cause?: unknown;
 }
-interface GscdumpRealtimeV1Snapshot {
+export interface GscdumpRealtimeV1Snapshot {
   transport: GscdumpRealtimeV1TransportState;
   freshness: GscdumpRealtimeV1Freshness;
   attempt: number;
@@ -67,7 +67,7 @@ interface GscdumpRealtimeV1Snapshot {
   head: RealtimeV1StreamHead | null;
   error: GscdumpRealtimeV1Error | null;
 }
-type GscdumpRealtimeV1Observation = {
+export type GscdumpRealtimeV1Observation = {
   type: 'state';
   state: GscdumpRealtimeV1Snapshot;
 } | {
@@ -83,7 +83,7 @@ type GscdumpRealtimeV1Observation = {
   code: 'unknown_event' | 'unknown_resource' | 'unsupported_event_version';
   event: RealtimeV1Event;
 };
-interface CreateGscdumpRealtimeV1ClientOptions {
+export interface CreateGscdumpRealtimeV1ClientOptions {
   /** Called for every connection attempt. A ticket is never reused. */
   ticketProvider: () => MaybePromise<unknown>;
   /** Required correctness effect for each contiguous durable event. */
@@ -96,7 +96,7 @@ interface CreateGscdumpRealtimeV1ClientOptions {
   runtime?: GscdumpRealtimeV1Runtime;
   sdkVersion?: string;
 }
-interface GscdumpRealtimeV1Client {
+export interface GscdumpRealtimeV1Client {
   start: () => Promise<void>;
   stop: () => void;
   getSnapshot: () => GscdumpRealtimeV1Snapshot;
@@ -105,5 +105,4 @@ interface GscdumpRealtimeV1Client {
  * Own the v1 cursor/ACK correctness state machine. Framework adapters provide
  * required effects; they never need to reproduce transport ordering rules.
  */
-declare function createGscdumpRealtimeV1Client(options: CreateGscdumpRealtimeV1ClientOptions): GscdumpRealtimeV1Client;
-export { CreateGscdumpRealtimeV1ClientOptions, GSCDUMP_REALTIME_V1_SDK_VERSION, GscdumpRealtimeV1Client, GscdumpRealtimeV1CursorStore, GscdumpRealtimeV1Error, GscdumpRealtimeV1ErrorCode, GscdumpRealtimeV1ErrorOptions, GscdumpRealtimeV1Freshness, GscdumpRealtimeV1Observation, GscdumpRealtimeV1ResyncReason, GscdumpRealtimeV1ResyncRequest, GscdumpRealtimeV1Runtime, GscdumpRealtimeV1Snapshot, GscdumpRealtimeV1SocketLike, GscdumpRealtimeV1TransportState, createGscdumpRealtimeV1Client };
+export declare function createGscdumpRealtimeV1Client(options: CreateGscdumpRealtimeV1ClientOptions): GscdumpRealtimeV1Client;

package/dist/v1/realtime.mjs

@@ -1,6 +1,6 @@
 import { utf8Size } from "../utf8.mjs";
 import { GSCDUMP_REALTIME_ACK_POLICY, GSCDUMP_REALTIME_CLOSE_CODES, GSCDUMP_REALTIME_CONNECTION_POLICY, GSCDUMP_REALTIME_LIMITS, GSCDUMP_REALTIME_PING, GSCDUMP_REALTIME_PONG, GSCDUMP_REALTIME_PROTOCOL_VERSION, GSCDUMP_REALTIME_SUBPROTOCOL, REALTIME_V1_EVENT_NAMES, REALTIME_V1_RESOURCE_TYPES, createRealtimeV1Schemas } from "@gscdump/contracts/v1/realtime";
-const GSCDUMP_REALTIME_V1_SDK_VERSION = "3.5.0";
+const GSCDUMP_REALTIME_V1_SDK_VERSION = "3.6.0";
 var GscdumpRealtimeV1Error = class extends Error {
 	tag = "GscdumpRealtimeV1Error";
 	code;
@@ -87,7 +87,7 @@ function createGscdumpRealtimeV1Client(options) {
 	const schemas = createRealtimeV1Schemas();
 	const runtime = options.runtime ?? defaultRuntime();
 	const cursorStore = options.cursorStore ?? createMemoryCursorStore();
-	const sdkVersion = options.sdkVersion ?? "3.5.0";
+	const sdkVersion = options.sdkVersion ?? "3.6.0";
 	if (!sdkVersion) throw new TypeError("sdkVersion cannot be empty.");
 	let running = false;
 	let epoch = 0;

package/dist/webhook.d.mts

@@ -1,11 +1,11 @@
 import { CANONICAL_WEBHOOK_EVENTS, 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 signWebhookPayload(payload: string | object, secret: string): Promise<string>;
-declare function verifyWebhookSignature(payload: string | object, signature: string | null | undefined, secret: string): Promise<boolean>;
-declare function parseWebhookPayload<TData extends Record<string, unknown> = Record<string, unknown>>(payload: string | object, options?: {
+export declare function signWebhookPayload(payload: string | object, secret: string): Promise<string>;
+export declare function verifyWebhookSignature(payload: string | object, signature: string | null | undefined, secret: string): Promise<boolean>;
+export 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, parseWebhookPayload, readWebhookHeaders, signWebhookPayload, verifyWebhookSignature };
+export 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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/sdk",
   "type": "module",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "Consumer SDK for hosted gscdump.com integrations.",
   "author": {
     "name": "Harlan Wilton",
@@ -144,14 +144,14 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@gscdump/contracts": "^3.5.0",
-    "gscdump": "^3.5.0",
+    "@gscdump/contracts": "^3.6.0",
+    "gscdump": "^3.6.0",
     "ofetch": "^1.5.1",
-    "zod": "^4.5.4"
+    "zod": "^4.6.1"
   },
   "devDependencies": {
-    "typescript": "^7.0.2",
-    "vitest": "^4.1.11"
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^5.0.0"
   },
   "scripts": {
     "build": "obuild",