@gscdump/analysis 0.40.1 → 1.0.0

package/dist/semantic/index.d.mts

@@ -1,117 +0,0 @@
-import { AnalysisQuerySource, QueryRow } from "@gscdump/engine/source";
-type ContentGapDevice = 'webgpu' | 'wasm';
-type ContentGapEmbeddingRole = 'query' | 'passage';
-type ContentGapExtractor = (texts: string[], opts: {
-  pooling: 'mean';
-  normalize: boolean;
-}) => Promise<{
-  data: Float32Array;
-  dims: number[];
-}>;
-interface EmbeddedContentGapTexts {
-  vectors: Float32Array[];
-  hits: number;
-  misses: number;
-}
-interface ContentGapEmbeddingCache {
-  getMany: (role: ContentGapEmbeddingRole, texts: string[]) => Promise<Map<string, Float32Array>>;
-  putMany: (role: ContentGapEmbeddingRole, entries: Array<[string, Float32Array]>) => Promise<void>;
-}
-declare function createMemoryContentGapCache(): ContentGapEmbeddingCache;
-interface ContentGapEmbeddingRuntime {
-  modelId: string;
-  queryPrefix: string;
-  selectDevice: (requested?: ContentGapDevice) => Promise<ContentGapDevice>;
-  loadExtractor: (device: ContentGapDevice) => Promise<ContentGapExtractor>;
-  embed: (extractor: ContentGapExtractor, role: ContentGapEmbeddingRole, texts: string[], transform: (text: string) => string, onProgress: (done: number, total: number) => void) => Promise<EmbeddedContentGapTexts>;
-}
-interface ContentGapQueryCandidate {
-  query: string;
-  impressions: number;
-  clicks: number;
-  avgPosition: number;
-  currentUrl: string;
-}
-interface ContentGapInputOptions {
-  maxQueries: number;
-  maxUrls: number;
-  minImpressions: number;
-}
-type ExecuteSql = (sql: string, params?: unknown[]) => Promise<QueryRow[]>;
-type NormalizeUrl = (url: string) => string;
-declare function fetchContentGapInputs(executeSql: ExecuteSql, options: ContentGapInputOptions, normalizeUrl: NormalizeUrl, now?: () => number): Promise<{
-  queries: ContentGapQueryCandidate[];
-  urls: string[];
-  sqlMs: number;
-}>;
-interface ContentGapResult {
-  query: string;
-  impressions: number;
-  clicks: number;
-  avgPosition: number;
-  currentUrl: string;
-  currentSimilarity: number;
-  suggestedUrl: string;
-  suggestedSimilarity: number;
-  alternatives: Array<{
-    url: string;
-    similarity: number;
-  }>;
-  divergence: number;
-  impact: number;
-}
-interface ContentGapProgress {
-  phase: 'idle' | 'loading-model' | 'fetching-data' | 'embedding-queries' | 'embedding-urls' | 'computing-gaps' | 'done' | 'error';
-  message: string;
-  done?: number;
-  total?: number;
-  modelMs?: number;
-  sqlMs?: number;
-  embedMs?: number;
-  computeMs?: number;
-}
-interface ContentGapOptions {
-  maxQueries?: number;
-  maxUrls?: number;
-  minImpressions?: number;
-  minDivergence?: number;
-  device?: 'webgpu' | 'wasm';
-  onProgress?: (progress: ContentGapProgress) => void;
-}
-/**
- * Content-gap requires a source with a raw-SQL escape hatch. The analyzer's
- * query shape (CTEs + window functions against `main.page_queries`) isn't
- * expressible as a {@link BuilderState}, so it bypasses `queryRows` and
- * goes directly through `source.executeSql`.
- */
-declare class ContentGapSourceUnsupportedError extends Error {
-  constructor(kind: string);
-}
-interface ContentGapAnalysis {
-  results: ContentGapResult[];
-  meta: {
-    modelMs: number;
-    sqlMs: number;
-    embedMs: number;
-    computeMs: number;
-    cacheHits: number;
-    totalInputs: number;
-    device: 'webgpu' | 'wasm';
-    modelId: string;
-  };
-}
-interface ContentGapAnalyzer {
-  analyze: (source: AnalysisQuerySource, opts?: ContentGapOptions) => Promise<ContentGapAnalysis>;
-}
-interface CreateContentGapAnalyzerOptions {
-  embeddings?: ContentGapEmbeddingRuntime;
-  loadInputs?: typeof fetchContentGapInputs;
-  now?: () => number;
-}
-declare function normalizeUrl(u: string): string;
-declare function deriveUrlText(url: string): string;
-declare function cosineNormalized(a: Float32Array, b: Float32Array): number;
-declare function rankContentGaps(queries: ContentGapQueryCandidate[], urls: string[], queryEmbeddings: Float32Array[], urlEmbeddings: Float32Array[], minDivergence: number): ContentGapResult[];
-declare function createContentGapAnalyzer(opts?: CreateContentGapAnalyzerOptions): ContentGapAnalyzer;
-declare function analyzeContentGap(source: AnalysisQuerySource, opts?: ContentGapOptions): Promise<ContentGapAnalysis>;
-export { type ContentGapAnalysis, type ContentGapAnalyzer, type ContentGapEmbeddingCache, type ContentGapEmbeddingRuntime, type ContentGapOptions, type ContentGapProgress, type ContentGapResult, ContentGapSourceUnsupportedError, type CreateContentGapAnalyzerOptions, analyzeContentGap, cosineNormalized, createContentGapAnalyzer, createMemoryContentGapCache, deriveUrlText, normalizeUrl, rankContentGaps };

package/dist/semantic/index.mjs

@@ -1,444 +0,0 @@
-const CONTENT_GAP_MODEL_ID = "Xenova/bge-base-en-v1.5";
-const CONTENT_GAP_QUERY_PREFIX = "Represent this sentence for searching relevant passages: ";
-const DB_NAME = "content-gap-embeddings";
-const STORE = "vectors";
-function cacheKey(role, text) {
-	return `${CONTENT_GAP_MODEL_ID}|${role}|${text}`;
-}
-function createIndexedDbContentGapCache() {
-	let dbPromise = null;
-	function openDb() {
-		if (dbPromise != null) return dbPromise;
-		dbPromise = new Promise((resolve, reject) => {
-			const req = indexedDB.open(DB_NAME, 1);
-			req.onupgradeneeded = () => {
-				const db = req.result;
-				if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE);
-			};
-			req.onsuccess = () => resolve(req.result);
-			req.onerror = () => reject(req.error ?? /* @__PURE__ */ new Error("indexedDB open failed"));
-		});
-		return dbPromise;
-	}
-	return {
-		async getMany(role, texts) {
-			const db = await openDb().catch(() => null);
-			if (db == null) return /* @__PURE__ */ new Map();
-			return new Promise((resolve) => {
-				const store = db.transaction(STORE, "readonly").objectStore(STORE);
-				const out = /* @__PURE__ */ new Map();
-				let pending = texts.length;
-				if (pending === 0) {
-					resolve(out);
-					return;
-				}
-				for (const text of texts) {
-					const req = store.get(cacheKey(role, text));
-					req.onsuccess = () => {
-						if (req.result instanceof Float32Array) out.set(text, req.result);
-						pending -= 1;
-						if (pending === 0) resolve(out);
-					};
-					req.onerror = () => {
-						pending -= 1;
-						if (pending === 0) resolve(out);
-					};
-				}
-			});
-		},
-		async putMany(role, entries) {
-			const db = await openDb().catch(() => null);
-			if (db == null) return;
-			await new Promise((resolve) => {
-				const tx = db.transaction(STORE, "readwrite");
-				for (const [text, vector] of entries) tx.objectStore(STORE).put(vector, cacheKey(role, text));
-				tx.oncomplete = () => resolve();
-				tx.onerror = () => resolve();
-				tx.onabort = () => resolve();
-			});
-		}
-	};
-}
-function createMemoryContentGapCache() {
-	const values = /* @__PURE__ */ new Map();
-	return {
-		async getMany(role, texts) {
-			const out = /* @__PURE__ */ new Map();
-			for (const text of texts) {
-				const value = values.get(cacheKey(role, text));
-				if (value) out.set(text, value);
-			}
-			return out;
-		},
-		async putMany(role, entries) {
-			for (const [text, vector] of entries) values.set(cacheKey(role, text), vector);
-		}
-	};
-}
-async function embedRawBatch(extractor, texts, onProgress, batchSize = 32) {
-	const result = [];
-	for (let i = 0; i < texts.length; i += batchSize) {
-		const batch = texts.slice(i, i + batchSize);
-		const out = await extractor(batch, {
-			pooling: "mean",
-			normalize: true
-		});
-		const dim = out.dims[out.dims.length - 1];
-		for (let k = 0; k < batch.length; k++) {
-			const start = k * dim;
-			result.push(new Float32Array(out.data.buffer, out.data.byteOffset + start * 4, dim).slice());
-		}
-		onProgress(result.length);
-	}
-	return result;
-}
-async function selectContentGapDevice(requested) {
-	let chosenDevice = "wasm";
-	if (requested === "webgpu" || requested == null) {
-		const gpu = globalThis.navigator?.gpu;
-		if (gpu != null) {
-			if (await gpu.requestAdapter().catch(() => null) != null) chosenDevice = "webgpu";
-		}
-	}
-	return chosenDevice;
-}
-async function loadContentGapExtractor(device) {
-	const { pipeline, env } = await import("@huggingface/transformers");
-	env.useBrowserCache = true;
-	return await pipeline("feature-extraction", CONTENT_GAP_MODEL_ID, {
-		device,
-		dtype: "fp32"
-	});
-}
-async function embedContentGapTexts(extractor, role, texts, transform, onProgress, cache) {
-	const cached = await cache.getMany(role, texts);
-	const vectors = Array.from({ length: texts.length });
-	const missIdx = [];
-	const missTexts = [];
-	for (let i = 0; i < texts.length; i++) {
-		const hit = cached.get(texts[i]);
-		if (hit != null) vectors[i] = hit;
-		else {
-			missIdx.push(i);
-			missTexts.push(transform(texts[i]));
-		}
-	}
-	const hits = cached.size;
-	const misses = missTexts.length;
-	onProgress(hits, texts.length);
-	if (missTexts.length > 0) {
-		const embedded = await embedRawBatch(extractor, missTexts, (done) => {
-			onProgress(hits + done, texts.length);
-		});
-		const toPersist = [];
-		for (let m = 0; m < embedded.length; m++) {
-			const i = missIdx[m];
-			vectors[i] = embedded[m];
-			toPersist.push([texts[i], embedded[m]]);
-		}
-		await cache.putMany(role, toPersist);
-	}
-	return {
-		vectors,
-		hits,
-		misses
-	};
-}
-function createContentGapEmbeddingRuntime(cache = createIndexedDbContentGapCache()) {
-	return {
-		modelId: CONTENT_GAP_MODEL_ID,
-		queryPrefix: CONTENT_GAP_QUERY_PREFIX,
-		selectDevice: selectContentGapDevice,
-		loadExtractor: loadContentGapExtractor,
-		embed(extractor, role, texts, transform, onProgress) {
-			return embedContentGapTexts(extractor, role, texts, transform, onProgress, cache);
-		}
-	};
-}
-async function fetchContentGapInputs(executeSql, options, normalizeUrl, now = () => performance.now()) {
-	const t1 = now();
-	const queryRows = await executeSql(`
-    WITH query_totals AS (
-      SELECT query,
-        SUM(impressions)::BIGINT AS total_impressions,
-        SUM(clicks)::BIGINT AS total_clicks,
-        SUM(sum_position) / NULLIF(SUM(impressions), 0) + 1 AS avg_position
-      FROM main.page_queries
-      WHERE query IS NOT NULL AND query <> ''
-      GROUP BY query
-      HAVING SUM(impressions) >= ?
-      ORDER BY total_impressions DESC
-      LIMIT ?
-    ),
-    per_query_url AS (
-      SELECT pk.query, pk.url,
-        SUM(pk.impressions)::BIGINT AS url_impressions,
-        SUM(pk.sum_position) / NULLIF(SUM(pk.impressions), 0) + 1 AS url_position,
-        ROW_NUMBER() OVER (PARTITION BY pk.query ORDER BY SUM(pk.impressions) DESC) AS rnk
-      FROM main.page_queries pk
-      JOIN query_totals qt USING (query)
-      WHERE pk.url IS NOT NULL AND pk.url <> ''
-      GROUP BY pk.query, pk.url
-    )
-    SELECT q.query, q.total_impressions AS impressions, q.total_clicks AS clicks, q.avg_position,
-      pu.url AS current_url, pu.url_position AS current_position
-    FROM query_totals q
-    JOIN per_query_url pu USING (query)
-    WHERE pu.rnk = 1
-  `, [Number(options.minImpressions), Number(options.maxQueries)]);
-	const urlRows = await executeSql(`
-    SELECT url, SUM(impressions)::BIGINT AS impressions
-    FROM main.page_queries
-    WHERE url IS NOT NULL AND url <> ''
-    GROUP BY url
-    ORDER BY impressions DESC
-    LIMIT ?
-  `, [Number(options.maxUrls)]);
-	const sqlMs = now() - t1;
-	const queries = queryRows.map((row) => ({
-		query: String(row.query),
-		impressions: Number(row.impressions),
-		clicks: Number(row.clicks),
-		avgPosition: Number(row.avg_position),
-		currentUrl: normalizeUrl(String(row.current_url))
-	}));
-	const urlAgg = /* @__PURE__ */ new Map();
-	for (const row of urlRows) {
-		const norm = normalizeUrl(String(row.url));
-		urlAgg.set(norm, (urlAgg.get(norm) ?? 0) + Number(row.impressions));
-	}
-	return {
-		queries,
-		urls: [...urlAgg.entries()].sort((a, b) => b[1] - a[1]).slice(0, Number(options.maxUrls)).map(([url]) => url),
-		sqlMs
-	};
-}
-var ContentGapSourceUnsupportedError = class extends Error {
-	constructor(kind) {
-		super(`content-gap requires a source with executeSql (got '${kind}'); use createBrowserQuerySource or createSqliteQuerySource`);
-		this.name = "ContentGapSourceUnsupportedError";
-	}
-};
-const ORIGIN_RE = /^https?:\/\/[^/]+/;
-const HTML_EXT_RE = /\.(html?|php|aspx?)$/i;
-const SEP_RE = /[-_]+/g;
-const DIGITS_ONLY_RE = /^\d+$/;
-const WWW_RE = /^www\./;
-const DOT_RE = /\./g;
-const HASH_RE = /#.*$/;
-const QUERY_RE = /\?.*$/;
-const TRAIL_SLASH_RE = /(?<=.)\/$/;
-function normalizeUrl(u) {
-	try {
-		const url = new URL(u);
-		url.hash = "";
-		url.search = "";
-		let path = url.pathname;
-		if (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1);
-		return `${url.origin}${path}`;
-	} catch {
-		return u.replace(HASH_RE, "").replace(QUERY_RE, "").replace(TRAIL_SLASH_RE, "");
-	}
-}
-function deriveUrlText(url) {
-	try {
-		const u = new URL(url);
-		const text = u.pathname.split("/").filter(Boolean).map((s) => decodeURIComponent(s).toLowerCase()).map((s) => s.replace(HTML_EXT_RE, "")).map((s) => s.replace(SEP_RE, " ")).filter((s) => s.length > 0 && !DIGITS_ONLY_RE.test(s)).join(" ");
-		if (text.length > 0) return text;
-		return u.hostname.replace(WWW_RE, "").replace(DOT_RE, " ");
-	} catch {
-		return url.replace(ORIGIN_RE, "").replace(SEP_RE, " ");
-	}
-}
-function cosineNormalized(a, b) {
-	let dot = 0;
-	const n = a.length;
-	for (let i = 0; i < n; i++) dot += a[i] * b[i];
-	return dot;
-}
-function notify(onProgress, progress) {
-	onProgress?.(progress);
-}
-function rankContentGaps(queries, urls, queryEmbeddings, urlEmbeddings, minDivergence) {
-	const urlIndex = /* @__PURE__ */ new Map();
-	for (let i = 0; i < urls.length; i++) urlIndex.set(urls[i], i);
-	const gaps = [];
-	for (let i = 0; i < queries.length; i++) {
-		const qr = queries[i];
-		const qEmb = queryEmbeddings[i];
-		const currentIdx = urlIndex.get(qr.currentUrl);
-		const top = [];
-		let currentSimilarity = 0;
-		for (let j = 0; j < urls.length; j++) {
-			const similarity = cosineNormalized(qEmb, urlEmbeddings[j]);
-			if (j === currentIdx) currentSimilarity = similarity;
-			let insertAt = top.length;
-			while (insertAt > 0 && similarity > top[insertAt - 1].similarity) insertAt--;
-			if (insertAt < 4) {
-				top.splice(insertAt, 0, {
-					url: urls[j],
-					similarity
-				});
-				if (top.length > 4) top.pop();
-			}
-		}
-		const suggested = top[0];
-		if (!suggested) continue;
-		const suggestedUrl = suggested.url;
-		const suggestedSimilarity = suggested.similarity;
-		if (suggestedUrl === qr.currentUrl) continue;
-		const divergence = suggestedSimilarity - currentSimilarity;
-		if (divergence < minDivergence) continue;
-		gaps.push({
-			query: qr.query,
-			impressions: qr.impressions,
-			clicks: qr.clicks,
-			avgPosition: qr.avgPosition,
-			currentUrl: qr.currentUrl,
-			currentSimilarity,
-			suggestedUrl,
-			suggestedSimilarity,
-			alternatives: top.slice(1),
-			divergence,
-			impact: qr.impressions * divergence
-		});
-	}
-	gaps.sort((a, b) => b.impact - a.impact);
-	return gaps;
-}
-async function runContentGapAnalysis(source, opts = {}, runtime) {
-	if (!source.executeSql) throw new ContentGapSourceUnsupportedError(source.name ?? "unknown");
-	const executeSql = source.executeSql.bind(source);
-	const { maxQueries = 1500, maxUrls = 400, minImpressions = 50, minDivergence = .12, device, onProgress } = opts;
-	notify(onProgress, {
-		phase: "loading-model",
-		message: "Checking device..."
-	});
-	const t0 = runtime.now();
-	const chosenDevice = await runtime.embeddings.selectDevice(device);
-	notify(onProgress, {
-		phase: "loading-model",
-		message: `Loading ${runtime.embeddings.modelId} on ${chosenDevice} (~110MB, cached after first run)...`
-	});
-	const extractor = await runtime.embeddings.loadExtractor(chosenDevice);
-	const modelMs = runtime.now() - t0;
-	notify(onProgress, {
-		phase: "fetching-data",
-		message: `Running SQL (device: ${chosenDevice})...`,
-		modelMs
-	});
-	const { queries, urls, sqlMs } = await runtime.loadInputs(executeSql, {
-		maxQueries,
-		maxUrls,
-		minImpressions
-	}, normalizeUrl, runtime.now);
-	if (queries.length === 0 || urls.length === 0) {
-		notify(onProgress, {
-			phase: "done",
-			message: "Not enough data to analyze.",
-			modelMs,
-			sqlMs
-		});
-		return {
-			results: [],
-			meta: {
-				modelMs,
-				sqlMs,
-				embedMs: 0,
-				computeMs: 0,
-				cacheHits: 0,
-				totalInputs: 0,
-				device: chosenDevice,
-				modelId: runtime.embeddings.modelId
-			}
-		};
-	}
-	const queryTexts = queries.map((q) => q.query);
-	const urlTexts = urls.map(deriveUrlText);
-	notify(onProgress, {
-		phase: "embedding-queries",
-		message: `Embedding ${queryTexts.length} queries on ${chosenDevice}...`,
-		total: queryTexts.length,
-		done: 0,
-		modelMs,
-		sqlMs
-	});
-	const t2 = runtime.now();
-	const queryEmbed = await runtime.embeddings.embed(extractor, "query", queryTexts, (t) => runtime.embeddings.queryPrefix + t, (done, total) => {
-		notify(onProgress, {
-			phase: "embedding-queries",
-			message: `Embedding ${queryTexts.length} queries on ${chosenDevice}...`,
-			done,
-			total,
-			modelMs,
-			sqlMs
-		});
-	});
-	notify(onProgress, {
-		phase: "embedding-urls",
-		message: `Embedding ${urls.length} URLs...`,
-		total: urls.length,
-		done: 0,
-		modelMs,
-		sqlMs
-	});
-	const urlEmbed = await runtime.embeddings.embed(extractor, "passage", urlTexts, (t) => t, (done, total) => {
-		notify(onProgress, {
-			phase: "embedding-urls",
-			message: `Embedding ${urls.length} URLs...`,
-			done,
-			total,
-			modelMs,
-			sqlMs
-		});
-	});
-	const embedMs = runtime.now() - t2;
-	notify(onProgress, {
-		phase: "computing-gaps",
-		message: "Computing semantic similarities...",
-		modelMs,
-		sqlMs,
-		embedMs
-	});
-	const t3 = runtime.now();
-	const gaps = rankContentGaps(queries, urls, queryEmbed.vectors, urlEmbed.vectors, minDivergence);
-	const computeMs = runtime.now() - t3;
-	const totalHits = queryEmbed.hits + urlEmbed.hits;
-	const totalInputs = queryTexts.length + urls.length;
-	const cacheNote = totalHits > 0 ? ` · ${totalHits}/${totalInputs} cache hits` : "";
-	notify(onProgress, {
-		phase: "done",
-		message: `Found ${gaps.length} content gaps across ${queries.length} queries${cacheNote}`,
-		modelMs,
-		sqlMs,
-		embedMs,
-		computeMs
-	});
-	return {
-		results: gaps.slice(0, 150),
-		meta: {
-			modelMs,
-			sqlMs,
-			embedMs,
-			computeMs,
-			cacheHits: totalHits,
-			totalInputs,
-			device: chosenDevice,
-			modelId: runtime.embeddings.modelId
-		}
-	};
-}
-function createContentGapAnalyzer(opts = {}) {
-	const runtime = {
-		embeddings: opts.embeddings ?? createContentGapEmbeddingRuntime(),
-		loadInputs: opts.loadInputs ?? fetchContentGapInputs,
-		now: opts.now ?? (() => performance.now())
-	};
-	return { analyze(source, options) {
-		return runContentGapAnalysis(source, options, runtime);
-	} };
-}
-function analyzeContentGap(source, opts = {}) {
-	return createContentGapAnalyzer().analyze(source, opts);
-}
-export { ContentGapSourceUnsupportedError, analyzeContentGap, cosineNormalized, createContentGapAnalyzer, createMemoryContentGapCache, deriveUrlText, normalizeUrl, rankContentGaps };

package/dist/source/index.d.mts

@@ -1,37 +0,0 @@
-import { BuilderState } from "gscdump/query";
-import { PlannerCapabilities } from "gscdump/query/plan";
-import { AnalysisQuerySource, QueryRow } from "@gscdump/engine/source";
-interface SyncedRange {
-  oldestDateSynced: string | null;
-  newestDateSynced: string | null;
-  /**
-   * Optional sorted list of `[start, end]` daily-key spans (`YYYY-MM-DD`,
-   * both inclusive) that the engine actually has partitions for. When set,
-   * `shouldRouteToLive` returns true for any requested range that overlaps
-   * a day NOT inside one of these spans — even when the request sits inside
-   * `oldestDateSynced..newestDateSynced`. Lets the composite catch *internal*
-   * manifest gaps (e.g. a missing monthly tier) that the outer envelope
-   * doesn't reveal. Spans must be sorted by `start` and non-overlapping.
-   */
-  coveredSpans?: ReadonlyArray<{
-    start: string;
-    end: string;
-  }>;
-}
-interface CompositeSourceOptions {
-  engine: AnalysisQuerySource;
-  live: AnalysisQuerySource;
-  site: SyncedRange;
-}
-declare function createCompositeSource(opts: CompositeSourceOptions): AnalysisQuerySource;
-/**
- * Permissive defaults: in-memory sources are usually test doubles, so they
- * advertise every capability unless the test explicitly narrows them.
- */
-declare const IN_MEMORY_DEFAULT_CAPABILITIES: PlannerCapabilities;
-interface InMemoryQuerySourceOptions {
-  queryRows: (state: BuilderState) => Promise<QueryRow[]> | QueryRow[];
-  capabilities?: PlannerCapabilities;
-}
-declare function createInMemoryQuerySource(options: InMemoryQuerySourceOptions): AnalysisQuerySource;
-export { type CompositeSourceOptions, IN_MEMORY_DEFAULT_CAPABILITIES, type InMemoryQuerySourceOptions, type SyncedRange, createCompositeSource, createInMemoryQuerySource };

package/dist/source/index.mjs

@@ -1,60 +0,0 @@
-import { canProxyToGsc } from "@gscdump/engine-gsc-api";
-import { extractDateRange } from "gscdump/query";
-import { isStateResolvable } from "gscdump/query/plan";
-function hasGapInCoveredSpans(start, end, coveredSpans) {
-	let cursor = start;
-	for (const span of coveredSpans) {
-		if (span.end < cursor) continue;
-		if (span.start > cursor) return true;
-		if (span.end >= end) return false;
-		cursor = nextDay(span.end);
-		if (cursor > end) return false;
-	}
-	return cursor <= end;
-}
-function nextDay(day) {
-	const t = Date.parse(`${day}T00:00:00Z`) + 864e5;
-	return new Date(t).toISOString().slice(0, 10);
-}
-function shouldRouteToLive(state, site) {
-	if (!canProxyToGsc(state)) return false;
-	if (!isStateResolvable(state)) return true;
-	const { startDate, endDate } = extractDateRange(state.filter);
-	if (!startDate || !endDate) return false;
-	if (!site.oldestDateSynced || !site.newestDateSynced) return true;
-	if (startDate < site.oldestDateSynced || endDate > site.newestDateSynced) return true;
-	if (site.coveredSpans && site.coveredSpans.length > 0) return hasGapInCoveredSpans(startDate, endDate, site.coveredSpans);
-	return false;
-}
-function createCompositeSource(opts) {
-	const { engine, live, site } = opts;
-	const engineExecuteSql = engine.executeSql;
-	return {
-		name: "composite-engine-live",
-		kind: "composite",
-		capabilities: engine.capabilities,
-		adapter: engine.adapter,
-		siteId: engine.siteId,
-		async queryRows(state) {
-			return shouldRouteToLive(state, site) ? live.queryRows(state) : engine.queryRows(state);
-		},
-		executeSql: engineExecuteSql ? (sql, params, execOpts) => engineExecuteSql(sql, params, execOpts) : void 0
-	};
-}
-const IN_MEMORY_DEFAULT_CAPABILITIES = {
-	regex: true,
-	multiDataset: true,
-	comparisonJoin: true,
-	windowTotals: true
-};
-function createInMemoryQuerySource(options) {
-	return {
-		name: "memory",
-		kind: "in-memory",
-		capabilities: options.capabilities ?? IN_MEMORY_DEFAULT_CAPABILITIES,
-		async queryRows(state) {
-			return await options.queryRows(state);
-		}
-	};
-}
-export { IN_MEMORY_DEFAULT_CAPABILITIES, createCompositeSource, createInMemoryQuerySource };