@gscdump/engine 1.4.0 → 1.4.1

package/dist/source/attached-table.mjs

@@ -0,0 +1,55 @@
+import { engineErrors } from "../errors.mjs";
+import { coerceRows } from "../coerce.mjs";
+var AttachedTableMissingError = class extends Error {
+	missing;
+	engineError;
+	constructor(missing) {
+		const engineError = engineErrors.attachedTableMissing(missing);
+		super(engineError.message);
+		this.missing = missing;
+		this.name = "AttachedTableMissingError";
+		this.engineError = engineError;
+	}
+};
+const ATTACHED_TABLE_CAPABILITIES = {
+	fileSets: true,
+	attachedTables: true,
+	regex: true
+};
+const ATTACHED_TABLE_CAPABILITIES_WITH_ADAPTER = {
+	...ATTACHED_TABLE_CAPABILITIES,
+	adapter: true
+};
+function rewriteForTableSource(sql, schema, fileSets) {
+	let out = sql;
+	for (const [key, fs] of Object.entries(fileSets)) {
+		const pattern = new RegExp(`read_parquet\\(\\s*\\{\\{${key}\\}\\}\\s*,\\s*union_by_name\\s*=\\s*true\\s*\\)`, "g");
+		out = out.replace(pattern, `${schema}.${fs.table}`);
+	}
+	return out;
+}
+function createAttachedTableSource(runner, options) {
+	const { schema, signal, attachedTables, adapter } = options;
+	const attachedSet = attachedTables ? new Set(attachedTables) : null;
+	return {
+		name: "attached-table",
+		kind: "browser",
+		capabilities: adapter ? ATTACHED_TABLE_CAPABILITIES_WITH_ADAPTER : ATTACHED_TABLE_CAPABILITIES,
+		adapter,
+		async queryRows() {
+			throw new Error("attached-table source: queryRows is not supported; use SQL analyzers");
+		},
+		async executeSql(sql, params, opts) {
+			signal?.throwIfAborted();
+			const fileSets = opts?.fileSets ?? {};
+			if (attachedSet) {
+				const missing = [];
+				for (const fs of Object.values(fileSets)) if (!attachedSet.has(fs.table)) missing.push(fs.table);
+				if (missing.length > 0) throw new AttachedTableMissingError(missing);
+			}
+			const rewritten = rewriteForTableSource(sql, schema, fileSets);
+			return coerceRows(await runner.query(rewritten, params ?? [], signal));
+		}
+	};
+}
+export { AttachedTableMissingError, createAttachedTableSource };

package/dist/source/create-sql-query-source.d.mts

@@ -0,0 +1,24 @@
+import { ResolverAdapter } from "../resolver/types.mjs";
+import { AnalysisQuerySource, AnalysisSourceKind, QueryRow, SourceCapabilities } from "./source-types.mjs";
+interface CreateSqlQuerySourceOptions<TKey extends string> {
+  /** Debug-only identifier surfaced on the source for error messages. */
+  name: string;
+  /** Telemetry tag stamped onto analyzer result meta. */
+  kind?: AnalysisSourceKind;
+  /** Dialect-specific adapter; compiles `BuilderState` → `{ sql, params }`. */
+  adapter: ResolverAdapter<TKey>;
+  /** Drives the underlying DB. Called for both typed queries and raw SQL. */
+  execute: (sql: string, params: unknown[]) => Promise<QueryRow[]>;
+  /** Tenant id for multi-tenant dialects; forwarded to `resolveToSQL`. */
+  siteId?: string | number;
+  /**
+   * Search-type scope for multi-tenant dialects; forwarded to `resolveToSQL`.
+   * `number` = int-encoded code (`SEARCH_TYPE_INT`) for INT `search_type`
+   * catalogs (bound bare so the int partition prunes); `string` otherwise.
+   */
+  searchType?: string | number;
+  /** Additional capability flags merged on top of `adapter.capabilities`. */
+  extraCapabilities?: Partial<SourceCapabilities>;
+}
+declare function createSqlQuerySource<TKey extends string>(options: CreateSqlQuerySourceOptions<TKey>): AnalysisQuerySource;
+export { CreateSqlQuerySourceOptions, createSqlQuerySource };

package/dist/source/create-sql-query-source.mjs

@@ -0,0 +1,28 @@
+import { coerceRows } from "../coerce.mjs";
+import { resolveToSQL } from "../resolver/compile.mjs";
+function createSqlQuerySource(options) {
+	const { name, kind, adapter, execute, siteId, searchType, extraCapabilities } = options;
+	return {
+		name,
+		kind,
+		capabilities: {
+			...adapter.capabilities,
+			...extraCapabilities,
+			adapter: true
+		},
+		adapter,
+		siteId,
+		async queryRows(state) {
+			const resolved = resolveToSQL(state, {
+				adapter,
+				siteId,
+				searchType
+			});
+			return coerceRows(await execute(resolved.sql, resolved.params));
+		},
+		async executeSql(sql, params) {
+			return coerceRows(await execute(sql, params ?? []));
+		}
+	};
+}
+export { createSqlQuerySource };

package/dist/source/index.d.mts

@@ -1,71 +1,11 @@
-import { Row, SearchType as SearchType$1, StorageEngine, TenantCtx } from "../_chunks/storage.mjs";
-import { AnalysisParams, AnalysisResult } from "../_chunks/analysis-types.mjs";
-import { ResolverAdapter } from "../_chunks/types.mjs";
-import { AnalysisQuerySource, AnalysisSourceKind, AnalyzerRegistry, ExecuteSqlOptions, FileSet, QueryRow, SourceCapabilities } from "../_chunks/registry.mjs";
-import { EngineError } from "../_chunks/errors.mjs";
-import "../_chunks/contracts.mjs";
+import { SearchType as SearchType$1, StorageEngine, TenantCtx } from "../storage.mjs";
+import { AnalysisParams, AnalysisResult } from "../analysis-types.mjs";
+import { AnalysisQuerySource, AnalysisSourceKind, ExecuteSqlOptions, FileSet, QueryRow, SourceCapabilities } from "./source-types.mjs";
+import { AnalyzerRegistry } from "../analyzer/registry.mjs";
+import { AttachedTableMissingError, AttachedTableRunner, AttachedTableSourceOptions, createAttachedTableSource } from "./attached-table.mjs";
+import { CreateSqlQuerySourceOptions, createSqlQuerySource } from "./create-sql-query-source.mjs";
 import { PlannerCapabilities } from "gscdump/query/plan";
 import { BuilderState } from "gscdump/query";
-interface AttachedTableRunner {
-  /**
-   * Run a query with positional (`?`) bound parameters. Return objects keyed
-   * by column name. BIGINT → number coercion is applied by the source factory
-   * (see `coerceRows`); runners only need to handle DATE → ISO string (or
-   * let the analyzer reducer normalize via `num(v)`/`str(v)`).
-   */
-  query: (sql: string, params?: unknown[], signal?: AbortSignal) => Promise<Row[]>;
-}
-interface AttachedTableSourceOptions {
-  /** Schema name the exported DuckDB file was attached under — e.g. `gsc`. */
-  schema: string;
-  /**
-   * Abort in-flight queries when the caller no longer cares about the
-   * result. Every `runner.query` call receives the same signal.
-   */
-  signal?: AbortSignal;
-  /**
-   * List of table names actually attached to this connection. When provided,
-   * `executeSql` short-circuits with a specific "table not attached" error
-   * if the SQL plan references a table that isn't in this list — letting
-   * callers (e.g. the analytics layer) route to cloud fallback without
-   * paying the SQL execution cost. Omit to disable the check.
-   */
-  attachedTables?: readonly string[];
-  /**
-   * Dialect adapter surfaced on the source for analyzers that compose SQL
-   * from a `BuilderState` at plan-build time (e.g. `data-query`,
-   * `data-detail`). Attached-table sources execute pg-flavored DuckDB SQL,
-   * so callers should pass `pgResolverAdapter` here.
-   */
-  adapter?: ResolverAdapter<any>;
-}
-declare class AttachedTableMissingError extends Error {
-  readonly missing: readonly string[];
-  readonly engineError: EngineError;
-  constructor(missing: readonly string[]);
-}
-declare function createAttachedTableSource(runner: AttachedTableRunner, options: AttachedTableSourceOptions): AnalysisQuerySource;
-interface CreateSqlQuerySourceOptions<TKey extends string> {
-  /** Debug-only identifier surfaced on the source for error messages. */
-  name: string;
-  /** Telemetry tag stamped onto analyzer result meta. */
-  kind?: AnalysisSourceKind;
-  /** Dialect-specific adapter; compiles `BuilderState` → `{ sql, params }`. */
-  adapter: ResolverAdapter<TKey>;
-  /** Drives the underlying DB. Called for both typed queries and raw SQL. */
-  execute: (sql: string, params: unknown[]) => Promise<QueryRow[]>;
-  /** Tenant id for multi-tenant dialects; forwarded to `resolveToSQL`. */
-  siteId?: string | number;
-  /**
-   * Search-type scope for multi-tenant dialects; forwarded to `resolveToSQL`.
-   * `number` = int-encoded code (`SEARCH_TYPE_INT`) for INT `search_type`
-   * catalogs (bound bare so the int partition prunes); `string` otherwise.
-   */
-  searchType?: string | number;
-  /** Additional capability flags merged on top of `adapter.capabilities`. */
-  extraCapabilities?: Partial<SourceCapabilities>;
-}
-declare function createSqlQuerySource<TKey extends string>(options: CreateSqlQuerySourceOptions<TKey>): AnalysisQuerySource;
 /**
  * Capabilities the engine query path honors. Matches what the DuckDB compiler
  * passes to `buildLogicalPlan`: regex pushes down; comparison joins and

package/dist/source/index.mjs

@@ -1,85 +1,12 @@
-import { engineErrors } from "../errors.mjs";
-import "../_chunks/layout.mjs";
-import { coerceRows } from "../_chunks/coerce.mjs";
-import { assertDimensionsSupported, getFilterDimensions, pgResolverAdapter, resolveToSQL } from "../_chunks/resolver.mjs";
-import { runAnalyzerFromSource } from "../_chunks/dispatch.mjs";
-var AttachedTableMissingError = class extends Error {
-	missing;
-	engineError;
-	constructor(missing) {
-		const engineError = engineErrors.attachedTableMissing(missing);
-		super(engineError.message);
-		this.missing = missing;
-		this.name = "AttachedTableMissingError";
-		this.engineError = engineError;
-	}
-};
-const ATTACHED_TABLE_CAPABILITIES = {
-	fileSets: true,
-	attachedTables: true,
-	regex: true
-};
-const ATTACHED_TABLE_CAPABILITIES_WITH_ADAPTER = {
-	...ATTACHED_TABLE_CAPABILITIES,
-	adapter: true
-};
-function rewriteForTableSource(sql, schema, fileSets) {
-	let out = sql;
-	for (const [key, fs] of Object.entries(fileSets)) {
-		const pattern = new RegExp(`read_parquet\\(\\s*\\{\\{${key}\\}\\}\\s*,\\s*union_by_name\\s*=\\s*true\\s*\\)`, "g");
-		out = out.replace(pattern, `${schema}.${fs.table}`);
-	}
-	return out;
-}
-function createAttachedTableSource(runner, options) {
-	const { schema, signal, attachedTables, adapter } = options;
-	const attachedSet = attachedTables ? new Set(attachedTables) : null;
-	return {
-		name: "attached-table",
-		kind: "browser",
-		capabilities: adapter ? ATTACHED_TABLE_CAPABILITIES_WITH_ADAPTER : ATTACHED_TABLE_CAPABILITIES,
-		adapter,
-		async queryRows() {
-			throw new Error("attached-table source: queryRows is not supported; use SQL analyzers");
-		},
-		async executeSql(sql, params, opts) {
-			signal?.throwIfAborted();
-			const fileSets = opts?.fileSets ?? {};
-			if (attachedSet) {
-				const missing = [];
-				for (const fs of Object.values(fileSets)) if (!attachedSet.has(fs.table)) missing.push(fs.table);
-				if (missing.length > 0) throw new AttachedTableMissingError(missing);
-			}
-			const rewritten = rewriteForTableSource(sql, schema, fileSets);
-			return coerceRows(await runner.query(rewritten, params ?? [], signal));
-		}
-	};
-}
-function createSqlQuerySource(options) {
-	const { name, kind, adapter, execute, siteId, searchType, extraCapabilities } = options;
-	return {
-		name,
-		kind,
-		capabilities: {
-			...adapter.capabilities,
-			...extraCapabilities,
-			adapter: true
-		},
-		adapter,
-		siteId,
-		async queryRows(state) {
-			const resolved = resolveToSQL(state, {
-				adapter,
-				siteId,
-				searchType
-			});
-			return coerceRows(await execute(resolved.sql, resolved.params));
-		},
-		async executeSql(sql, params) {
-			return coerceRows(await execute(sql, params ?? []));
-		}
-	};
-}
+import "../layout.mjs";
+import { coerceRows } from "../coerce.mjs";
+import { assertDimensionsSupported } from "../resolver/datasets.mjs";
+import { getFilterDimensions } from "../resolver/filter-utils.mjs";
+import { pgResolverAdapter } from "../resolver/pg-adapter.mjs";
+import "../resolver/index.mjs";
+import { runAnalyzerFromSource } from "../analyzer/dispatch.mjs";
+import { AttachedTableMissingError, createAttachedTableSource } from "./attached-table.mjs";
+import { createSqlQuerySource } from "./create-sql-query-source.mjs";
 function isMetricDimension(dim) {
 	return [
 		"clicks",

package/dist/source/source-types.d.mts

@@ -0,0 +1,49 @@
+import { ResolverAdapter } from "../resolver/types.mjs";
+import { PlannerCapabilities } from "gscdump/query/plan";
+import { BuilderState } from "gscdump/query";
+import { TableName } from "@gscdump/contracts";
+type QueryRow = Record<string, unknown>;
+interface FileSet {
+  table: TableName;
+  partitions: string[];
+}
+interface ExecuteSqlOptions {
+  fileSets?: Record<string, FileSet>;
+}
+/**
+ * Flat capability bag: planner-side flags (`regex`, `comparisonJoin`, ...)
+ * mixed with storage-side flags. SQL execution is not a capability flag —
+ * callers probe `typeof source.executeSql === 'function'`.
+ */
+interface SourceCapabilities extends PlannerCapabilities {
+  attachedTables?: boolean;
+  fileSets?: boolean;
+  /**
+   * true iff the source provides a `ResolverAdapter` for analyzers that
+   * compose SQL from a typed `BuilderState` at plan-build time.
+   */
+  adapter?: boolean;
+}
+type AnalysisSourceKind = 'local' | 'browser' | 'live' | 'in-memory' | 'composite' | 'attached-table';
+interface AnalysisQuerySource {
+  name?: string;
+  /** Telemetry tag stamped onto analyzer result meta; not used for routing. */
+  kind?: AnalysisSourceKind;
+  capabilities: SourceCapabilities;
+  /**
+   * Dialect adapter surfaced for analyzers that compose SQL from a
+   * `BuilderState` at plan-build time. Optional for pure row sources.
+   */
+  adapter?: ResolverAdapter<any>;
+  /** Tenant scope; multi-tenant dialects (sqlite/D1) require it, parquet omits it. */
+  siteId?: string | number;
+  queryRows: (state: BuilderState) => Promise<QueryRow[]>;
+  /**
+   * Optional raw-SQL escape hatch. Receives the compiled SQL plan with
+   * `{{FILES}}` placeholders; sources that advertise `capabilities.fileSets`
+   * consume `opts.fileSets`, others ignore them. Implementations MUST coerce
+   * BigInts to numbers before returning (see Source invariant above).
+   */
+  executeSql?: (sql: string, params?: unknown[], opts?: ExecuteSqlOptions) => Promise<QueryRow[]>;
+}
+export { AnalysisQuerySource, AnalysisSourceKind, ExecuteSqlOptions, FileSet, QueryRow, SourceCapabilities };

package/dist/{_chunks/storage.d.mts → storage.d.mts}

@@ -1,18 +1,8 @@
-import { ParquetQueryFilter } from "./libs/hyparquet.mjs";
+import { CompactionThresholds } from "./compaction.mjs";
+import { ParquetQueryFilter } from "./node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/types/index.mjs";
+import "./node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/types/node.mjs";
 import { BuilderState, SearchType, SearchType as SearchType$1 } from "gscdump/query";
 import { Grain, Grain as Grain$1, Row, Row as Row$1, TableName, TableName as TableName$1, TenantCtx, TenantCtx as TenantCtx$1 } from "@gscdump/contracts";
-/**
- * Per-tier age threshold in days. Default ladder collapses on these gates:
- * - raw → d7 once a daily file is older than `raw` days (default 7).
- * - d7 → d30 once the entire weekly bucket sits behind `d7` days (default 30).
- * - d30 → d90 once the entire monthly bucket sits behind `d30` days (default 90).
- */
-interface CompactionThresholds {
-  raw?: number;
-  d7?: number;
-  d30?: number;
-}
-declare function enumeratePartitions(startDate: string, endDate: string): string[];
 interface WriteCtx extends TenantCtx {
   table: TableName;
   date?: string;
@@ -554,4 +544,4 @@ interface EngineOptions {
   executor: QueryExecutor;
   now?: () => number;
 }
-export { CodecCtx, CompactionThresholds, CompactionTier, DataSource, EngineOptions, FileSetRef, GcCtx, type Grain$1 as Grain, ListLiveFilter, LockScope, ManifestEntry, ManifestPurgeResult, ManifestStore, ParquetCodec, PurgeFilter, PurgeResult, PurgeUrlsResult, QueryCtx, QueryExecuteOptions, QueryExecuteResult, QueryExecutor, QueryProfiler, QueryResult, QuerySpan, type Row$1 as Row, RunSQLOptions, type SearchType$1 as SearchType, StorageEngine, SyncState, SyncStateDetail, SyncStateFilter, SyncStateKind, SyncStateScope, type TableName$1 as TableName, type TenantCtx$1 as TenantCtx, Watermark, WatermarkFilter, WatermarkScope, WriteCtx, WriteResult, enumeratePartitions };
+export { CodecCtx, CompactionTier, DataSource, EngineOptions, FileSetRef, GcCtx, type Grain$1 as Grain, ListLiveFilter, LockScope, ManifestEntry, ManifestPurgeResult, ManifestStore, ParquetCodec, PurgeFilter, PurgeResult, PurgeUrlsResult, QueryCtx, QueryExecuteOptions, QueryExecuteResult, QueryExecutor, QueryProfiler, QueryResult, QuerySpan, type Row$1 as Row, RunSQLOptions, type SearchType$1 as SearchType, StorageEngine, SyncState, SyncStateDetail, SyncStateFilter, SyncStateKind, SyncStateScope, type TableName$1 as TableName, type TenantCtx$1 as TenantCtx, Watermark, WatermarkFilter, WatermarkScope, WriteCtx, WriteResult };

package/dist/sync-config.d.mts

@@ -0,0 +1,36 @@
+import { SearchType } from "./storage.mjs";
+import { EngineError } from "./errors.mjs";
+import { Result } from "gscdump/result";
+import { TableName } from "@gscdump/contracts";
+type SyncTableName = Extract<TableName, 'pages' | 'queries' | 'countries' | 'page_queries' | 'dates'>;
+declare const TABLES_BY_SEARCH_TYPE: Record<SearchType, readonly SyncTableName[]>;
+declare function parseEnabledSearchTypes(raw: string | null | undefined): SearchType[];
+/**
+ * Errors-as-values core for {@link validateEnabledSearchTypes}: returns a typed
+ * `invalid-search-types` `EngineError` instead of throwing, so a host saving the
+ * persisted config can map a bad value to a 4xx rather than a 500.
+ */
+declare function validateEnabledSearchTypesResult(value: unknown): Result<SearchType[], EngineError>;
+declare function validateEnabledSearchTypes(value: unknown): SearchType[];
+declare const TABLE_TIERS: {
+  readonly pages: 'critical';
+  readonly queries: 'critical';
+  readonly countries: 'standard';
+  readonly dates: 'standard';
+  readonly page_queries: 'extended';
+};
+type TieredTableName = keyof typeof TABLE_TIERS;
+type TableTier = 'critical' | 'standard' | 'extended';
+type DateWeight = 'fresh' | 'recent' | 'historical';
+declare function getTableTier(table: string): TableTier;
+declare function getTablesForTier(tier: TableTier): TieredTableName[];
+declare function getDateWeight(date: string, now?: Date): DateWeight;
+declare const TIER_PRIORITY: Record<TableTier, number>;
+declare const WEIGHT_PRIORITY: Record<DateWeight, number>;
+declare const MAX_GSC_PAGES_R2 = 40;
+declare const ROW_LIMIT_R2 = 25000;
+declare const MIN_SYNC_IMPRESSIONS = 1;
+declare const MIN_COUNTRY_IMPRESSIONS = 10;
+declare const MAX_SITEMAP_URLS_PER_SITE = 50000;
+declare const MAX_TRACKED_URLS_PER_SITE = 200000;
+export { DateWeight, MAX_GSC_PAGES_R2, MAX_SITEMAP_URLS_PER_SITE, MAX_TRACKED_URLS_PER_SITE, MIN_COUNTRY_IMPRESSIONS, MIN_SYNC_IMPRESSIONS, ROW_LIMIT_R2, SyncTableName, TABLES_BY_SEARCH_TYPE, TABLE_TIERS, TIER_PRIORITY, TableTier, TieredTableName, WEIGHT_PRIORITY, getDateWeight, getTableTier, getTablesForTier, parseEnabledSearchTypes, validateEnabledSearchTypes, validateEnabledSearchTypesResult };

package/dist/sync-config.mjs

@@ -0,0 +1,98 @@
+import { engineErrorToException, engineErrors } from "./errors.mjs";
+import { err, ok, unwrapResult } from "gscdump/result";
+const TABLES_BY_SEARCH_TYPE = {
+	web: [
+		"pages",
+		"queries",
+		"countries",
+		"page_queries",
+		"dates"
+	],
+	discover: [
+		"pages",
+		"countries",
+		"dates"
+	],
+	news: [
+		"pages",
+		"countries",
+		"dates"
+	],
+	googleNews: [
+		"pages",
+		"countries",
+		"dates"
+	],
+	image: [
+		"pages",
+		"countries",
+		"dates"
+	],
+	video: [
+		"pages",
+		"countries",
+		"dates"
+	]
+};
+function parseEnabledSearchTypes(raw) {
+	if (!raw) return ["web"];
+	const parsed = JSON.parse(raw);
+	if (!Array.isArray(parsed) || parsed.length === 0) return ["web"];
+	const valid = parsed.filter((v) => typeof v === "string" && v in TABLES_BY_SEARCH_TYPE);
+	if (valid.length === 0) return ["web"];
+	if (!valid.includes("web")) valid.unshift("web");
+	return valid;
+}
+function validateEnabledSearchTypesResult(value) {
+	if (!Array.isArray(value) || value.length === 0) return err(engineErrors.searchTypesNotArray());
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const v of value) {
+		if (typeof v !== "string" || !(v in TABLES_BY_SEARCH_TYPE)) return err(engineErrors.unknownSearchType(v));
+		if (seen.has(v)) continue;
+		seen.add(v);
+		out.push(v);
+	}
+	if (!out.includes("web")) return err(engineErrors.searchTypesMissingWeb());
+	return ok(out);
+}
+function validateEnabledSearchTypes(value) {
+	return unwrapResult(validateEnabledSearchTypesResult(value), engineErrorToException);
+}
+const TABLE_TIERS = {
+	pages: "critical",
+	queries: "critical",
+	countries: "standard",
+	dates: "standard",
+	page_queries: "extended"
+};
+function getTableTier(table) {
+	return TABLE_TIERS[table] || "extended";
+}
+function getTablesForTier(tier) {
+	return Object.entries(TABLE_TIERS).filter(([_, t]) => t === tier).map(([name]) => name);
+}
+function getDateWeight(date, now = /* @__PURE__ */ new Date()) {
+	const target = new Date(date);
+	const daysAgo = Math.floor((now.getTime() - target.getTime()) / (1e3 * 60 * 60 * 24));
+	if (daysAgo <= 3) return "fresh";
+	if (daysAgo <= 60) return "recent";
+	return "historical";
+}
+const TIER_PRIORITY = {
+	critical: 0,
+	standard: 1,
+	extended: 2
+};
+const WEIGHT_PRIORITY = {
+	fresh: 0,
+	recent: 1,
+	historical: 2
+};
+const MAX_GSC_PAGES_R2 = 40;
+const ROW_LIMIT_R2 = 25e3;
+const MIN_SYNC_IMPRESSIONS = 1;
+const MIN_COUNTRY_IMPRESSIONS = 10;
+const MAX_SITEMAP_URLS_PER_SITE = 5e4;
+const MAX_TRACKED_URLS_PER_SITE = 2e5;
+export { MAX_GSC_PAGES_R2, MAX_SITEMAP_URLS_PER_SITE, MAX_TRACKED_URLS_PER_SITE, MIN_COUNTRY_IMPRESSIONS, MIN_SYNC_IMPRESSIONS, ROW_LIMIT_R2, TABLES_BY_SEARCH_TYPE, TABLE_TIERS, TIER_PRIORITY, WEIGHT_PRIORITY, getDateWeight, getTableTier, getTablesForTier, parseEnabledSearchTypes, validateEnabledSearchTypes, validateEnabledSearchTypesResult };

package/dist/vendor/hysnappy-purejs.mjs

@@ -1,2 +1,13 @@
-import { snappyUncompress, snappyUncompressor } from "../_chunks/libs/hyparquet-compressors.mjs";
+import { snappyUncompress as snappyUncompress$1 } from "../node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/snappy.mjs";
+function decode(input, outputLength) {
+	const output = new Uint8Array(outputLength);
+	snappyUncompress$1(input, output);
+	return output;
+}
+function snappyUncompressor() {
+	return decode;
+}
+function snappyUncompress(input, outputLength) {
+	return decode(input, outputLength);
+}
 export { snappyUncompress, snappyUncompressor };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/engine",
   "type": "module",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Append-only Parquet/DuckDB storage engine + planner + adapters for the gscdump pipeline. Node + edge runtimes; opt-in heavy peers.",
   "author": {
     "name": "Harlan Wilton",
@@ -176,9 +176,9 @@
   "dependencies": {
     "drizzle-orm": "1.0.0-rc.3",
     "proper-lockfile": "^4.1.2",
-    "@gscdump/contracts": "^1.4.0",
-    "gscdump": "^1.4.0",
-    "@gscdump/lakehouse": "^1.4.0"
+    "@gscdump/contracts": "^1.4.1",
+    "@gscdump/lakehouse": "^1.4.1",
+    "gscdump": "^1.4.1"
   },
   "devDependencies": {
     "@duckdb/duckdb-wasm": "1.33.1-dev57.0",

package/dist/_chunks/analysis-types.d.mts

@@ -1,57 +0,0 @@
-import { BuilderState, SearchType } from "gscdump/query";
-type AnalysisTool = 'striking-distance' | 'opportunity' | 'movers' | 'decay' | 'zero-click' | 'brand' | 'cannibalization' | 'clustering' | 'concentration' | 'seasonality' | 'trends' | 'ctr-anomaly' | 'position-volatility' | 'long-tail' | 'intent-atlas' | 'query-migration' | 'bayesian-ctr' | 'stl-decompose' | 'change-point' | 'bipartite-pagerank' | 'survival' | 'position-distribution' | 'ctr-curve' | 'dark-traffic' | 'content-velocity' | 'keyword-breadth' | 'device-gap' | 'data-query' | 'data-detail';
-interface AnalysisParams {
-  type: AnalysisTool;
-  startDate?: string;
-  endDate?: string;
-  prevStartDate?: string;
-  prevEndDate?: string;
-  brandTerms?: string[];
-  limit?: number;
-  offset?: number;
-  /**
-   * movers: select a single direction and paginate within it. When set, the
-   * analyzer filters to that direction, reports `meta.total` as the full
-   * pre-pagination count for the direction, and applies `limit`/`offset`. When
-   * unset, both directions are returned uncapped (the top-N callers slice
-   * themselves).
-   */
-  direction?: 'rising' | 'declining';
-  /** Sort column. Each analyzer enforces its own whitelist. */
-  sortBy?: string;
-  /** Sort direction. Default per-analyzer. */
-  sortDir?: 'asc' | 'desc';
-  minPosition?: number;
-  maxPosition?: number;
-  minImpressions?: number;
-  maxCtr?: number;
-  minPages?: number;
-  maxPositionSpread?: number;
-  minClusterSize?: number;
-  clusterBy?: 'prefix' | 'intent' | 'both';
-  dimension?: 'pages' | 'keywords';
-  topN?: number;
-  metric?: 'clicks' | 'impressions';
-  changeThreshold?: number;
-  minPreviousClicks?: number;
-  threshold?: number;
-  weeks?: number;
-  minWeeksWithData?: number;
-  /** content-velocity lookback window in days (max 365, default 90). */
-  days?: number;
-  /** data-query / data-detail primary BuilderState. */
-  q?: BuilderState;
-  /** data-query / data-detail optional comparison-period BuilderState. */
-  qc?: BuilderState;
-  /** data-query comparison filter applied to joined current/previous rows. */
-  comparisonFilter?: 'new' | 'lost' | 'improving' | 'declining';
-  /** GSC slice the analysis is scoped to. Undefined = analyzer runs cross-type (today's behaviour for web-only sites). */
-  searchType?: SearchType;
-}
-interface AnalysisResult {
-  results: Record<string, unknown>[];
-  meta: Record<string, unknown>;
-}
-/** Coerce arbitrary value (number, bigint, string, null) to number, defaulting to 0. */
-declare function num(v: unknown): number;
-export { AnalysisParams, AnalysisResult, AnalysisTool, num };

package/dist/_chunks/contracts.d.mts

@@ -1 +0,0 @@
-import "./storage.mjs";