@gscdump/sdk 3.0.0 → 3.1.0

package/dist/canonical-json.mjs

@@ -0,0 +1,6 @@
+function canonicalJson(value) {
+	if (value == null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${Array.from(value, (item) => canonicalJson(item)).join(",")}]`;
+	return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
+}
+export { canonicalJson };

package/dist/hosted-query.d.mts

@@ -1,7 +1,7 @@
-import { BuilderStateWire, DataDetailOptions, DataQueryOptions, GscdumpPageTrendParams, GscdumpQueryTrendParams, IndexingDiagnosticsParams, IndexingUrlsParams, SourceInfoOptions } from "@gscdump/contracts";
-type GscSearchType = 'web' | 'image' | 'video' | 'news' | 'discover' | 'googleNews';
+import { BuilderStateWire, DataDetailOptions, DataQueryOptions, IndexingDiagnosticsParams, IndexingUrlsParams, SourceInfoOptions } from "@gscdump/contracts";
+import { GscSearchType, GscSearchType as GscSearchType$2 } from "@gscdump/contracts/search-types";
 interface SearchTypeOptions {
-  searchType?: GscSearchType;
+  searchType?: GscSearchType$2;
 }
 interface SourceRangeOptions {
   start?: string;
@@ -15,17 +15,13 @@ interface AnalysisSourcesOptions extends SearchTypeOptions, SourceRangeOptions {
   maxRows?: number;
   maxFiles?: number;
 }
-declare const DEFAULT_SEARCH_TYPE: GscSearchType;
-declare function withDefaultSearchType<T extends object>(value: T, searchType?: GscSearchType): T & SearchTypeOptions & Record<string, unknown>;
-declare function withDefaultSearchType<T>(value: T, searchType?: GscSearchType): T;
-declare function searchTypeQuery(searchType?: GscSearchType): Record<string, string>;
-declare function dateRangeOptionsQuery(options: SourceRangeOptions | undefined): Record<string, string>;
+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>;
-declare function queryTrendQuery(params: GscdumpQueryTrendParams): Record<string, string>;
-declare function pageTrendQuery(params: GscdumpPageTrendParams): Record<string, string>;
-export { AnalysisSourcesOptions, DEFAULT_SEARCH_TYPE, GscSearchType, SearchTypeOptions, SourceRangeOptions, dataDetailQuery, dataQuery, dateRangeOptionsQuery, indexingDiagnosticsQuery, indexingUrlsQuery, pageTrendQuery, queryTrendQuery, searchTypeQuery, sourceInfoQuery, tablesQuery, withDefaultSearchType };
+export { AnalysisSourcesOptions, DEFAULT_SEARCH_TYPE, type GscSearchType, SearchTypeOptions, SourceRangeOptions, dataDetailQuery, dataQuery, indexingDiagnosticsQuery, indexingUrlsQuery, sourceInfoQuery, tablesQuery, withDefaultSearchType };

package/dist/hosted-query.mjs

@@ -1,3 +1,4 @@
+import { canonicalJson } from "./canonical-json.mjs";
 const DEFAULT_SEARCH_TYPE = "web";
 function isAnalysisSourcesOptions(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value);
@@ -13,11 +14,6 @@ function withDefaultSearchType(value, searchType) {
 function searchTypeQuery(searchType) {
 	return { searchType: searchType ?? "web" };
 }
-function stableJson(value) {
-	if (value == null || typeof value !== "object") return JSON.stringify(value) ?? "null";
-	if (Array.isArray(value)) return `[${value.map((item) => item === void 0 ? "null" : stableJson(item)).join(",")}]`;
-	return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(",")}}`;
-}
 function dateRangeOptionsQuery(options) {
 	const query = {};
 	const start = options?.start ?? options?.startDate;
@@ -49,10 +45,10 @@ function dataQuery(state, options) {
 	const opts = options;
 	const scoped = withDefaultSearchType(state, opts?.searchType);
 	const query = {
-		q: stableJson(scoped),
+		q: canonicalJson(scoped),
 		searchType: scoped.searchType ?? "web"
 	};
-	if (opts?.comparison) query.qc = stableJson(withDefaultSearchType(opts.comparison, scoped.searchType));
+	if (opts?.comparison) query.qc = canonicalJson(withDefaultSearchType(opts.comparison, scoped.searchType));
 	if (opts?.filter) query.filter = opts.filter;
 	return query;
 }
@@ -60,10 +56,10 @@ function dataDetailQuery(state, options) {
 	const opts = options;
 	const scoped = withDefaultSearchType(state, opts?.searchType);
 	const query = {
-		q: stableJson(scoped),
+		q: canonicalJson(scoped),
 		searchType: scoped.searchType ?? "web"
 	};
-	if (opts?.comparison) query.qc = stableJson(withDefaultSearchType(opts.comparison, scoped.searchType));
+	if (opts?.comparison) query.qc = canonicalJson(withDefaultSearchType(opts.comparison, scoped.searchType));
 	return query;
 }
 function indexingUrlsQuery(params = {}) {
@@ -82,24 +78,4 @@ function indexingDiagnosticsQuery(params = {}) {
 	if (params.sampleLimit != null) query.sampleLimit = params.sampleLimit;
 	return query;
 }
-function queryTrendQuery(params) {
-	const query = {
-		startDate: params.startDate,
-		endDate: params.endDate,
-		searchType: params.searchType ?? "web"
-	};
-	if (params.prevStartDate) query.prevStartDate = params.prevStartDate;
-	if (params.prevEndDate) query.prevEndDate = params.prevEndDate;
-	return query;
-}
-function pageTrendQuery(params) {
-	const query = {
-		startDate: params.startDate,
-		endDate: params.endDate,
-		searchType: params.searchType ?? "web"
-	};
-	if (params.prevStartDate) query.prevStartDate = params.prevStartDate;
-	if (params.prevEndDate) query.prevEndDate = params.prevEndDate;
-	return query;
-}
-export { DEFAULT_SEARCH_TYPE, dataDetailQuery, dataQuery, dateRangeOptionsQuery, indexingDiagnosticsQuery, indexingUrlsQuery, pageTrendQuery, queryTrendQuery, searchTypeQuery, sourceInfoQuery, tablesQuery, withDefaultSearchType };
+export { DEFAULT_SEARCH_TYPE, dataDetailQuery, dataQuery, indexingDiagnosticsQuery, indexingUrlsQuery, sourceInfoQuery, tablesQuery, withDefaultSearchType };

package/dist/lifecycle.d.mts

@@ -6,9 +6,8 @@ import { GscdumpSyncStatusResponse, GscdumpUserSite, PartnerLifecycleSite } from
  */
 type LifecycleSiteLike = Pick<PartnerLifecycleSite, 'siteId' | 'externalSiteId' | 'requestedUrl' | 'gscPropertyUrl' | 'permissionLevel' | 'analytics' | 'indexing' | 'latestError' | 'updatedAt'>;
 declare function analyticsStatusToSyncStatus(status: LifecycleSiteLike['analytics']['status']): GscdumpUserSite['syncStatus'];
-declare function lifecycleSiteToUserSite(site: LifecycleSiteLike): GscdumpUserSite;
 declare function lifecycleSiteToSyncStatus(site: LifecycleSiteLike): GscdumpSyncStatusResponse;
 declare function findLifecycleSite<TSite extends LifecycleSiteLike>(lifecycle: {
   sites: readonly TSite[];
 }, siteIdOrPropertyUrl: string): TSite | null;
-export { LifecycleSiteLike, analyticsStatusToSyncStatus, findLifecycleSite, lifecycleSiteToSyncStatus, lifecycleSiteToUserSite };
+export { LifecycleSiteLike, analyticsStatusToSyncStatus, findLifecycleSite, lifecycleSiteToSyncStatus };

package/dist/lifecycle.mjs

@@ -19,25 +19,6 @@ function analyticsStatusToSyncStatus(status) {
 		default: return "pending";
 	}
 }
-function lifecycleSiteToUserSite(site) {
-	const syncStatus = analyticsStatusToSyncStatus(site.analytics.status);
-	return {
-		siteId: site.siteId,
-		siteUrl: site.gscPropertyUrl || site.requestedUrl,
-		analyticsSyncStatus: syncStatus,
-		analyticsSyncProgress: site.analytics.progress,
-		syncStatus,
-		syncProgress: site.analytics.progress,
-		indexingEligible: site.indexing.eligible,
-		indexingIneligibleReason: site.indexing.reason,
-		indexingPermissionLevel: site.permissionLevel,
-		indexingStatus: site.indexing.status === "ready" ? "complete" : site.indexing.status === "not_requested" ? "not_started" : "indexing",
-		indexingProgress: site.indexing.progress,
-		lastSyncAt: site.updatedAt ? Date.parse(site.updatedAt) : null,
-		newestDateSynced: site.analytics.syncedRange.newest,
-		oldestDateSynced: site.analytics.syncedRange.oldest
-	};
-}
 function lifecycleSiteToSyncStatus(site) {
 	const syncStatus = analyticsStatusToSyncStatus(site.analytics.status);
 	const completed = site.analytics.progress.completed;
@@ -81,4 +62,4 @@ function findLifecycleSite(lifecycle, siteIdOrPropertyUrl) {
 	const propertyKey = normalizeGscPropertyKey(siteIdOrPropertyUrl);
 	return lifecycle.sites.find((site) => site.siteId === siteIdOrPropertyUrl || site.externalSiteId === siteIdOrPropertyUrl || !!propertyKey && normalizeGscPropertyKey(site.gscPropertyUrl) === propertyKey || !site.gscPropertyUrl && normalizeLifecycleUrl(site.requestedUrl) === normalized || !propertyKey && normalizeLifecycleUrl(site.requestedUrl) === normalized) ?? null;
 }
-export { analyticsStatusToSyncStatus, findLifecycleSite, lifecycleSiteToSyncStatus, lifecycleSiteToUserSite };
+export { analyticsStatusToSyncStatus, findLifecycleSite, lifecycleSiteToSyncStatus };

package/dist/period.mjs

@@ -1,6 +1,5 @@
 import "./gsc-constants.mjs";
-import { resolveWindow } from "@gscdump/engine/period";
-import { addDays } from "gscdump/dates";
+import { addDays, resolveWindow } from "gscdump/dates";
 function isCustomPeriod(p) {
 	return typeof p === "string" && p.startsWith("custom:");
 }

package/dist/request.mjs

@@ -1,3 +1,4 @@
+import { canonicalJson } from "./canonical-json.mjs";
 import { partnerErrorToException, toPartnerError } from "./errors.mjs";
 import { err, ok, unwrapResult } from "gscdump/result";
 import { ofetch } from "ofetch";
@@ -26,11 +27,6 @@ function shouldValidate(options, phase) {
 function parseWith(schema, value) {
 	return schema ? schema.parse(value) : value;
 }
-function stableJson(value) {
-	if (value == null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
-	if (Array.isArray(value)) return `[${value.map((item) => item === void 0 ? "undefined" : stableJson(item)).join(",")}]`;
-	return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(",")}}`;
-}
 function headersKey(headers) {
 	return [...headers.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}:${value}`).join("\n");
 }
@@ -48,7 +44,7 @@ function createHostedRequester(options, defaults) {
 		const { dedupe: _dedupe, ...fetchInit } = init;
 		const headers = mergeHeaders(await resolveHeaders(options), init.headers);
 		const fullPath = buildPath(apiBase, path);
-		const dedupeKey = dedupe && isDedupeable(init) ? `${(init.method ?? "GET").toUpperCase()} ${fullPath}\nq=${stableJson(init.query)}\nb=${stableJson(init.body)}\nh=${headersKey(headers)}` : null;
+		const dedupeKey = dedupe && isDedupeable(init) ? `${(init.method ?? "GET").toUpperCase()} ${fullPath}\nq=${canonicalJson(init.query)}\nb=${canonicalJson(init.body)}\nh=${headersKey(headers)}` : null;
 		if (dedupeKey) {
 			const existing = inflight.get(dedupeKey);
 			if (existing) return existing;

package/dist/site-baseline.d.mts

@@ -24,7 +24,6 @@ interface SiteTypeBaseline {
   /** The default growth lever when the site is healthy and leading. */
   primaryGoal: 'content' | 'authority' | 'conversion' | 'coverage';
 }
-declare const SITE_TYPE_BASELINE: Record<SiteType, SiteTypeBaseline>;
 declare function siteTypeBaseline(raw: string | null | undefined): SiteTypeBaseline;
 type PeerStanding = 'leader' | 'on_par' | 'behind' | 'unknown';
 /** How much to trust the standing: a median over 1–2 peers is noisy. */
@@ -66,4 +65,4 @@ declare function derivePeerStanding(input: PeerBaselineInput): {
  * 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, SITE_TYPE_BASELINE, SiteBaseline, SiteType, SiteTypeBaseline, derivePeerStanding, deriveSiteBaseline, normalizeSiteType, siteTypeBaseline };
+export { PeerBaselineInput, PeerConfidence, PeerStanding, SiteBaseline, SiteType, SiteTypeBaseline, derivePeerStanding, deriveSiteBaseline, normalizeSiteType, siteTypeBaseline };

package/dist/site-baseline.mjs

@@ -109,4 +109,4 @@ function deriveSiteBaseline(rawType, peer = {}) {
 		goalKind: baseline.primaryGoal
 	};
 }
-export { SITE_TYPE_BASELINE, derivePeerStanding, deriveSiteBaseline, normalizeSiteType, siteTypeBaseline };
+export { derivePeerStanding, deriveSiteBaseline, normalizeSiteType, siteTypeBaseline };

package/dist/v1/http.d.mts

@@ -1,7 +1,20 @@
 import { ZodTypeAny, z } from "zod";
-import { GscdumpV1ErrorEnvelope, GscdumpV1Operation as GscdumpV1Operation$1, GscdumpV1OperationId as GscdumpV1OperationId$1 } from "@gscdump/contracts/v1/http";
+import { GscdumpV1ErrorEnvelope, GscdumpV1Operation as GscdumpV1Operation$1, GscdumpV1OperationId as GscdumpV1OperationId$1, createGscdumpV1Protocol } from "@gscdump/contracts/v1/http";
 type MaybePromise<T> = T | Promise<T>;
 type ValueOf<T> = T[keyof T];
+type GscdumpV1ProtocolShape = ReturnType<typeof createGscdumpV1Protocol>;
+type GscdumpV1RegistryOperations = GscdumpV1ProtocolShape['surfaces']['partner']['operations'] & GscdumpV1ProtocolShape['surfaces']['analytics']['operations'] & GscdumpV1ProtocolShape['surfaces']['realtime']['operations'];
+type GscdumpV1RegistryMethodName = keyof GscdumpV1RegistryOperations & string;
+interface GscdumpV1ClientMethodAliases {
+  queryRows: 'queryAnalyticsRows';
+  queryReport: 'queryAnalyticsReport';
+  queryReportDetail: 'queryAnalyticsReportDetail';
+  getStreamHead: 'getRealtimeStreamHead';
+  createTicket: 'createRealtimeTicket';
+}
+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;
 type OperationById<TId extends GscdumpV1OperationId> = Extract<GscdumpV1Operation, {
@@ -64,61 +77,13 @@ declare class GscdumpV1Error extends Error {
   constructor(options: GscdumpV1ErrorOptions);
 }
 declare function isGscdumpV1Error(error: unknown): error is GscdumpV1Error;
-interface GscdumpV1Client {
+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 = {
   execute: <TId extends GscdumpV1OperationId>(operation: TId, input: NoInfer<GscdumpV1OperationInput<TId>>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<TId>>;
-  getUserLifecycle: (input: GscdumpV1OperationInput<'partner.users.lifecycle.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.users.lifecycle.get'>>;
-  listAvailableSites: (input: GscdumpV1OperationInput<'partner.users.sites.available.list'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.users.sites.available.list'>>;
-  createSite: (input: GscdumpV1OperationInput<'partner.users.sites.create'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.users.sites.create'>>;
-  createUser: (input: GscdumpV1OperationInput<'partner.users.create'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.users.create'>>;
-  updateUserTokens: (input: GscdumpV1OperationInput<'partner.users.tokens.update'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.users.tokens.update'>>;
-  getSiteIndexing: (input: GscdumpV1OperationInput<'partner.sites.indexing.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.indexing.get'>>;
-  listSiteIndexingUrls: (input: GscdumpV1OperationInput<'partner.sites.indexing.urls.list'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.indexing.urls.list'>>;
-  listSiteBingIndexingEvidence: (input: GscdumpV1OperationInput<'partner.sites.indexing.bing.evidence.list'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.indexing.bing.evidence.list'>>;
-  listSiteIndexingTransitions: (input: GscdumpV1OperationInput<'partner.sites.indexing.transitions.list'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.indexing.transitions.list'>>;
-  getSiteIndexingDiagnostics: (input: GscdumpV1OperationInput<'partner.sites.indexing.diagnostics.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.indexing.diagnostics.get'>>;
-  getSiteSitemaps: (input: GscdumpV1OperationInput<'partner.sites.sitemaps.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.sitemaps.get'>>;
-  getSiteSitemapChanges: (input: GscdumpV1OperationInput<'partner.sites.sitemaps.changes.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.sitemaps.changes.get'>>;
-  listSitemapUrls: (input: GscdumpV1OperationInput<'partner.sites.sitemaps.urls.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.sitemaps.urls.get'>>;
-  getSitemapExport: (input: GscdumpV1OperationInput<'partner.sites.sitemaps.export.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.sitemaps.export.get'>>;
-  getSiteAnalysis: (input: GscdumpV1OperationInput<'partner.sites.analysis.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.analysis.get'>>;
-  getSiteAnalysisBundle: (input: GscdumpV1OperationInput<'partner.sites.analysis.bundle.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.analysis.bundle.get'>>;
-  deleteSite: (input: GscdumpV1OperationInput<'partner.sites.delete'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.delete'>>;
-  getCanonicalMismatches: (input: GscdumpV1OperationInput<'partner.sites.canonical.mismatches.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.canonical.mismatches.get'>>;
-  inspectSiteUrls: (input: GscdumpV1OperationInput<'partner.sites.indexing.inspect.create'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.indexing.inspect.create'>>;
-  recoverSitePermission: (input: GscdumpV1OperationInput<'partner.sites.permission.recover'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.permission.recover'>>;
-  queryKeywordSparklines: (input: GscdumpV1OperationInput<'partner.sites.keyword.sparklines.query'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.keyword.sparklines.query'>>;
-  getQueryTrend: (input: GscdumpV1OperationInput<'partner.sites.query.trend.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.query.trend.get'>>;
-  getPageTrend: (input: GscdumpV1OperationInput<'partner.sites.page.trend.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.page.trend.get'>>;
-  getContentVelocity: (input: GscdumpV1OperationInput<'partner.sites.content.velocity.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.content.velocity.get'>>;
-  getCtrCurve: (input: GscdumpV1OperationInput<'partner.sites.ctr.curve.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.ctr.curve.get'>>;
-  getDarkTraffic: (input: GscdumpV1OperationInput<'partner.sites.dark.traffic.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.dark.traffic.get'>>;
-  getDeviceGap: (input: GscdumpV1OperationInput<'partner.sites.device.gap.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.device.gap.get'>>;
-  getKeywordBreadth: (input: GscdumpV1OperationInput<'partner.sites.keyword.breadth.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.keyword.breadth.get'>>;
-  getPositionDistribution: (input: GscdumpV1OperationInput<'partner.sites.position.distribution.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.position.distribution.get'>>;
-  getTopAssociation: (input: GscdumpV1OperationInput<'partner.sites.top.association.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.top.association.get'>>;
-  getIndexPercent: (input: GscdumpV1OperationInput<'partner.sites.index.percent.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.index.percent.get'>>;
-  createSitemapAction: (input: GscdumpV1OperationInput<'partner.sites.sitemaps.action.create'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.sitemaps.action.create'>>;
-  querySitemapMembership: (input: GscdumpV1OperationInput<'partner.sites.sitemaps.membership.query'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.sitemaps.membership.query'>>;
-  createTeam: (input: GscdumpV1OperationInput<'partner.teams.create'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.teams.create'>>;
-  renameTeam: (input: GscdumpV1OperationInput<'partner.teams.rename'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.teams.rename'>>;
-  deleteTeam: (input: GscdumpV1OperationInput<'partner.teams.delete'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.teams.delete'>>;
-  listTeamMembers: (input: GscdumpV1OperationInput<'partner.teams.members.list'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.teams.members.list'>>;
-  addTeamMember: (input: GscdumpV1OperationInput<'partner.teams.members.add'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.teams.members.add'>>;
-  updateTeamMemberRole: (input: GscdumpV1OperationInput<'partner.teams.members.role.update'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.teams.members.role.update'>>;
-  removeTeamMember: (input: GscdumpV1OperationInput<'partner.teams.members.remove'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.teams.members.remove'>>;
-  updateSiteTeam: (input: GscdumpV1OperationInput<'partner.sites.team.update'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.sites.team.update'>>;
-  getTeamCatalog: (input: GscdumpV1OperationInput<'partner.teams.catalog.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.teams.catalog.get'>>;
-  bindTeamCatalog: (input: GscdumpV1OperationInput<'partner.teams.catalog.bind'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.teams.catalog.bind'>>;
-  getSiteIntIdCrosswalk: (input: GscdumpV1OperationInput<'partner.users.sites.crosswalk.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.users.sites.crosswalk.get'>>;
-  deleteUser: (input: GscdumpV1OperationInput<'partner.users.delete'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.users.delete'>>;
-  createVerificationToken: (input: GscdumpV1OperationInput<'partner.users.verification.token.create'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.users.verification.token.create'>>;
-  addAndVerifySite: (input: GscdumpV1OperationInput<'partner.users.sites.verify.create'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'partner.users.sites.verify.create'>>;
-  queryAnalyticsRows: (input: GscdumpV1OperationInput<'analytics.rows.query'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'analytics.rows.query'>>;
-  queryAnalyticsReport: (input: GscdumpV1OperationInput<'analytics.reports.query'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'analytics.reports.query'>>;
-  queryAnalyticsReportDetail: (input: GscdumpV1OperationInput<'analytics.reports.detail.query'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'analytics.reports.detail.query'>>;
-  getRealtimeStreamHead: (input?: GscdumpV1OperationInput<'realtime.stream.head.get'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'realtime.stream.head.get'>>;
-  createRealtimeTicket: (input: GscdumpV1OperationInput<'realtime.tickets.create'>, options?: GscdumpV1ExecuteOptions) => Promise<GscdumpV1OperationResponse<'realtime.tickets.create'>>;
-}
+} & { [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 };

package/dist/v1/http.mjs

@@ -21,9 +21,6 @@ function isGscdumpV1Error(error) {
 	return error instanceof GscdumpV1Error;
 }
 const DEFAULT_API_ROOT = "https://gscdump.com/api";
-const API_PREFIX_RE = /^\/api(?=\/)/;
-const TRAILING_SLASH_RE = /\/+$/;
-const LEADING_SLASH_RE = /^\/+/;
 function validationDetails(cause) {
 	if (typeof cause === "object" && cause !== null && "issues" in cause) return { issues: cause.issues };
 	return {};
@@ -65,10 +62,6 @@ function resolveRetryOptions(options) {
 		maxDelayMs
 	};
 }
-function resolveApiUrl(apiRoot, contractPath) {
-	const relative = contractPath.replace(API_PREFIX_RE, "").replace(LEADING_SLASH_RE, "");
-	return `${apiRoot.replace(TRAILING_SLASH_RE, "")}/${relative}`;
-}
 function appendQueryValue(search, key, value) {
 	if (value === void 0) return;
 	if (Array.isArray(value)) {
@@ -104,13 +97,13 @@ function parseLocation(operation, location, value) {
 		throw requestValidationError(operation.id, location, cause);
 	}
 }
-function prepareRequest(buildOperationPath, surface, operation, input, options) {
+function prepareRequest(buildOperationPath, operation, input, options) {
 	let path;
 	if (operation.request.params === null) {
 		assertAbsentLocation(operation.id, "params", input.params);
-		path = buildOperationPath(surface, operation);
+		path = buildOperationPath();
 	} else try {
-		path = buildOperationPath(surface, operation, input.params);
+		path = buildOperationPath(input.params);
 	} catch (cause) {
 		throw requestValidationError(operation.id, "params", cause);
 	}
@@ -241,46 +234,46 @@ async function readJson(response) {
 function requestIdFrom(response) {
 	return response.headers.get("x-request-id") ?? void 0;
 }
-function operationLookup(protocol, listOperations) {
-	const operations = /* @__PURE__ */ new Map();
-	for (const { operation, surface } of listOperations(protocol)) operations.set(operation.id, {
-		operation,
-		surface
+let runtimePromise;
+function getRuntime() {
+	return runtimePromise ??= import("@gscdump/contracts/v1/http").then(({ createGscdumpV1Protocol, createHttpV1Registry, isUnknownHttpV1OperationError }) => {
+		const protocol = createGscdumpV1Protocol();
+		return {
+			isUnknownOperationError: isUnknownHttpV1OperationError,
+			protocol,
+			registry: createHttpV1Registry(protocol)
+		};
 	});
-	return operations;
 }
 function createGscdumpV1Client(options) {
 	const retryOptions = resolveRetryOptions(options.retry);
 	const apiRoot = options.apiRoot ?? DEFAULT_API_ROOT;
 	const fetchImpl = options.fetch ?? globalThis.fetch;
-	let runtimePromise;
 	if (typeof fetchImpl !== "function") throw new TypeError("createGscdumpV1Client requires a fetch implementation in this runtime.");
-	function getRuntime() {
-		return runtimePromise ??= import("@gscdump/contracts/v1/http").then(({ buildHttpOperationPath: buildOperationPath, createGscdumpV1Protocol, listHttpOperations: listOperations }) => {
-			const protocol = createGscdumpV1Protocol();
-			return {
-				buildOperationPath,
-				operations: operationLookup(protocol, listOperations),
-				protocol
-			};
-		});
-	}
 	const execute = executeUntyped;
 	async function executeUntyped(operationId, input, executeOptions = {}) {
-		const { buildOperationPath, operations, protocol } = await getRuntime();
-		const entry = operations.get(operationId);
+		const { isUnknownOperationError, protocol, registry } = await getRuntime();
+		const entry = (() => {
+			try {
+				return registry.operation(operationId);
+			} catch (cause) {
+				if (isUnknownOperationError(cause)) return null;
+				throw cause;
+			}
+		})();
 		if (!entry) throw new GscdumpV1Error({
 			code: "request_validation",
 			message: `Unknown gscdump v1 operation: ${operationId}`,
 			retryable: false,
 			details: { operationId }
 		});
-		const { operation, surface } = entry;
+		const { operation } = entry;
 		if (typeof input !== "object" || input === null || Array.isArray(input)) throw requestValidationError(operation.id, "input", /* @__PURE__ */ new TypeError("input must be an object."));
-		const prepared = prepareRequest(buildOperationPath, surface, operation, input, executeOptions);
+		const buildRegisteredPath = registry.path;
+		const prepared = prepareRequest((params) => buildRegisteredPath(operationId, params, { apiRoot }), operation, input, executeOptions);
 		let url;
 		try {
-			url = appendQuery(resolveApiUrl(apiRoot, prepared.path), prepared.query);
+			url = appendQuery(prepared.path, prepared.query);
 		} catch (cause) {
 			throw requestValidationError(operation.id, "query", cause);
 		}

package/dist/v1/realtime.d.mts

@@ -1,6 +1,6 @@
 import { RealtimeV1Cursor, RealtimeV1Event, RealtimeV1StreamHead, RealtimeV1StreamId } from "@gscdump/contracts/v1/realtime";
 type MaybePromise<T> = T | Promise<T>;
-declare const GSCDUMP_REALTIME_V1_SDK_VERSION: "3.0.0";
+declare const GSCDUMP_REALTIME_V1_SDK_VERSION: "3.1.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';

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.0.0";
+const GSCDUMP_REALTIME_V1_SDK_VERSION = "3.1.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.0.0";
+	const sdkVersion = options.sdkVersion ?? "3.1.0";
 	if (!sdkVersion) throw new TypeError("sdkVersion cannot be empty.");
 	let running = false;
 	let epoch = 0;

package/dist/webhook.d.mts

@@ -1,24 +1,6 @@
-import { PartnerApiError } from "./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>;
+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>;
-/**
- * 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;
@@ -26,4 +8,4 @@ declare function parseWebhookPayload<TData extends Record<string, unknown> = Rec
   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 };
+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 };

package/dist/webhook.mjs

@@ -1,15 +1,7 @@
 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;
+import { CANONICAL_WEBHOOK_EVENTS, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, 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 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);
 }
@@ -39,32 +31,6 @@ async function hmacSha256(payload, secret) {
 	}, 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))}`;
 }
@@ -115,4 +81,4 @@ function readWebhookHeaders(headers) {
 		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 };
+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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/sdk",
   "type": "module",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Consumer SDK for hosted gscdump.com integrations.",
   "author": {
     "name": "Harlan Wilton",
@@ -146,9 +146,8 @@
   "dependencies": {
     "ofetch": "^1.5.1",
     "zod": "^4.4.3",
-    "@gscdump/contracts": "^3.0.0",
-    "@gscdump/engine": "^3.0.0",
-    "gscdump": "^3.0.0"
+    "@gscdump/contracts": "^3.1.0",
+    "gscdump": "^3.1.0"
   },
   "devDependencies": {
     "typescript": "^7.0.2",