@gscdump/engine 7.8.4 → 7.9.0

package/dist/resolver/compile.d.mts

@@ -1,4 +1,4 @@
-import { ComparisonFilter, ComparisonOrderBy, ExtraQuery, ResolvedComparisonSQL, ResolvedSQL, ResolvedSQLOptimized, ResolverOptions } from "./types.mjs";
+import { ComparisonFilter, ComparisonOrderBy, ExtraQuery, ResolvedComparisonSQL, ResolvedComparisonTotalsSQL, ResolvedSQL, ResolvedSQLOptimized, ResolverOptions } from "./types.mjs";
 import { BuilderState } from "gscdump/query";
 export declare function resolveToSQLOptimized<TK extends string>(state: BuilderState, options: ResolverOptions<TK>): ResolvedSQLOptimized;
 export declare function resolveToSQL<TK extends string>(state: BuilderState, options: ResolverOptions<TK>): ResolvedSQL;
@@ -6,7 +6,43 @@ export declare function buildTotalsSql<TK extends string>(state: BuilderState, o
   sql: string;
   params: unknown[];
 };
+/**
+ * Totals SQL for both windows of a comparison read, as one statement when it
+ * can be. Pass the two dimensionless states that {@link buildTotalsSql} would
+ * receive; their filters choose the table.
+ *
+ * The `Combined` statement scans both date ranges once. Each metric sums only
+ * the rows of its own window, so days between the windows count in neither
+ * total, and days that both windows contain count in both. Its one row holds
+ * the current metrics under their own names and the previous metrics as
+ * `prevClicks`, `prevImpressions`, `prevCtr`, and `prevPosition`. Read it
+ * with {@link splitComparisonTotalsRow}. It is a single-table aggregate with
+ * no GROUP BY, the same shape as a `buildTotalsSql` statement.
+ *
+ * If the windows read different tables or filter different rows, the result
+ * is `Separate`: the two `buildTotalsSql` statements.
+ */
+export declare function buildComparisonTotalsSql<TK extends string>(current: BuilderState, previous: BuilderState, options: ResolverOptions<TK>): ResolvedComparisonTotalsSQL;
+/**
+ * Split the row of a `Combined` {@link buildComparisonTotalsSql} statement
+ * into the metrics of each window. A metric the statement did not select stays
+ * absent. With no row, both windows are empty.
+ */
+export declare function splitComparisonTotalsRow(row: Record<string, unknown> | undefined): {
+  current: Record<string, unknown>;
+  previous: Record<string, unknown>;
+};
 export declare function resolveComparisonSQL<TK extends string>(current: BuilderState, previous: BuilderState, options: ResolverOptions<TK>, comparisonFilter?: ComparisonFilter, comparisonOrderBy?: ComparisonOrderBy): ResolvedComparisonSQL;
+/**
+ * The comparison row query of {@link resolveComparisonSQL}, with the count in
+ * the same statement. Every row carries `totalCount`: the number of joined
+ * rows that pass the comparison filter, before LIMIT and OFFSET.
+ *
+ * Only a row can carry the count. Without OFFSET, an empty result means
+ * `totalCount` is 0. With an OFFSET past the last row, run the count query of
+ * {@link resolveComparisonSQL} instead.
+ */
+export declare function resolveComparisonSQLOptimized<TK extends string>(current: BuilderState, previous: BuilderState, options: ResolverOptions<TK>, comparisonFilter?: ComparisonFilter, comparisonOrderBy?: ComparisonOrderBy): ResolvedSQLOptimized;
 /**
  * Enrich Canonical Query groups with their raw variants.
  * Supply selected keys to limit aggregation to the current page.

package/dist/resolver/compile.mjs

@@ -110,12 +110,13 @@ function buildScope(state, options) {
 	if (adapter.searchTypeColRef && searchType != null) wherePredicates.push(sql`${adapter.searchTypeColRef(tableKey)} = ${searchType}`);
 	wherePredicates.push(sql`${adapter.dateColRef(tableKey)} >= ${plan.dateRange.startDate}`);
 	wherePredicates.push(sql`${adapter.dateColRef(tableKey)} <= ${plan.dateRange.endDate}`);
-	wherePredicates.push(...adapter.prefilterPredicates(prefilters, tableKey));
+	const filterPredicates = [...adapter.prefilterPredicates(prefilters, tableKey)];
 	const dimSql = plan.dimensionFilterTree ? compileFilterTree(plan.dimensionFilterTree, adapter, tableKey) : void 0;
-	if (dimSql) wherePredicates.push(dimSql);
-	else if (!plan.dimensionFilterTree) wherePredicates.push(...adapter.dimensionPredicates(dimFilters, tableKey));
+	if (dimSql) filterPredicates.push(dimSql);
+	else if (!plan.dimensionFilterTree) filterPredicates.push(...adapter.dimensionPredicates(dimFilters, tableKey));
 	const tl = adapter.topLevelPredicate(topLevelFilters(plan), tableKey);
-	if (tl) wherePredicates.push(tl);
+	if (tl) filterPredicates.push(tl);
+	wherePredicates.push(...filterPredicates);
 	return {
 		plan,
 		tableKey,
@@ -123,6 +124,7 @@ function buildScope(state, options) {
 		hasDate,
 		metrics,
 		wherePredicates,
+		filterPredicates,
 		having: adapter.havingPredicates(metricFilters, tableKey),
 		dimFilters,
 		startDate: plan.dateRange.startDate,
@@ -250,7 +252,77 @@ function buildTotalsSql(state, options) {
 	const selectExprs = metrics.map((m) => sql`${adapter.metricSql(m, tableKey)} as ${aliasRaw(m)}`);
 	return compileCollapsed(adapter, wherePredicates.length > 0 ? sql`SELECT ${joinComma(selectExprs)} FROM ${table} WHERE ${joinAnd(wherePredicates)}` : sql`SELECT ${joinComma(selectExprs)} FROM ${table}`);
 }
-function resolveComparisonSQL(current, previous, options, comparisonFilter, comparisonOrderBy) {
+const PREVIOUS_TOTALS_ALIAS = {
+	clicks: "prevClicks",
+	impressions: "prevImpressions",
+	ctr: "prevCtr",
+	position: "prevPosition"
+};
+function windowMetricSql(metric, columns, inWindow) {
+	const sum = (column) => sql`SUM(CASE WHEN ${inWindow} THEN ${columns[column]} END)`;
+	switch (metric) {
+		case "clicks": return sql`CAST(${sum("clicks")} AS DOUBLE)`;
+		case "impressions": return sql`CAST(${sum("impressions")} AS DOUBLE)`;
+		case "ctr": return sql`CAST(${sum("clicks")} AS DOUBLE) / NULLIF(${sum("impressions")}, 0)`;
+		case "position": return sql`${sum("sum_position")} / NULLIF(${sum("impressions")}, 0) + 1`;
+	}
+}
+function sharesTotalsScope(adapter, current, previous) {
+	if (current.tableKey !== previous.tableKey || current.queryCanonicalUsed !== previous.queryCanonicalUsed) return false;
+	const left = adapter.compile(joinAnd(current.filterPredicates));
+	const right = adapter.compile(joinAnd(previous.filterPredicates));
+	return left.sql === right.sql && left.params.length === right.params.length && left.params.every((value, index) => Object.is(value, right.params[index]));
+}
+function buildComparisonTotalsSql(current, previous, options) {
+	const { adapter, siteId, searchType } = options;
+	const currentScope = buildScope(withMinimumImpressions(current, options), options);
+	const previousScope = buildScope(withMinimumImpressions(previous, options), options);
+	if (!sharesTotalsScope(adapter, currentScope, previousScope)) return {
+		_tag: "Separate",
+		current: buildTotalsSql(current, options),
+		previous: buildTotalsSql(previous, options)
+	};
+	const { tableKey } = currentScope;
+	const columns = adapter.schema[tableKey];
+	const dateCol = adapter.dateColRef(tableKey);
+	const currentRange = currentScope.plan.dateRange;
+	const previousRange = previousScope.plan.dateRange;
+	const inWindow = (range) => sql`${dateCol} >= ${range.startDate} AND ${dateCol} <= ${range.endDate}`;
+	const selectExprs = [...currentScope.metrics.map((m) => sql`${windowMetricSql(m, columns, inWindow(currentRange))} as ${aliasRaw(m)}`), ...previousScope.metrics.map((m) => sql`${windowMetricSql(m, columns, inWindow(previousRange))} as ${aliasRaw(PREVIOUS_TOTALS_ALIAS[m])}`)];
+	const wherePredicates = [];
+	if (adapter.siteIdColRef && siteId != null) wherePredicates.push(sql`${adapter.siteIdColRef(tableKey)} = ${siteId}`);
+	if (adapter.searchTypeColRef && searchType != null) wherePredicates.push(sql`${adapter.searchTypeColRef(tableKey)} = ${searchType}`);
+	const spanStart = currentRange.startDate < previousRange.startDate ? currentRange.startDate : previousRange.startDate;
+	const spanEnd = currentRange.endDate > previousRange.endDate ? currentRange.endDate : previousRange.endDate;
+	wherePredicates.push(sql`${dateCol} >= ${spanStart}`);
+	wherePredicates.push(sql`${dateCol} <= ${spanEnd}`);
+	wherePredicates.push(sql`((${inWindow(currentRange)}) OR (${inWindow(previousRange)}))`);
+	wherePredicates.push(...currentScope.filterPredicates);
+	const table = adapter.fromSql(tableKey, { queryCanonical: currentScope.queryCanonicalUsed });
+	const compiled = compileCollapsed(adapter, sql`SELECT ${joinComma(selectExprs)} FROM ${table} WHERE ${joinAnd(wherePredicates)}`);
+	return {
+		_tag: "Combined",
+		sql: compiled.sql,
+		params: compiled.params
+	};
+}
+function splitComparisonTotalsRow(row) {
+	const current = {};
+	const previous = {};
+	if (!row) return {
+		current,
+		previous
+	};
+	for (const [metric, previousAlias] of Object.entries(PREVIOUS_TOTALS_ALIAS)) {
+		if (metric in row) current[metric] = row[metric];
+		if (previousAlias in row) previous[metric] = row[previousAlias];
+	}
+	return {
+		current,
+		previous
+	};
+}
+function buildComparisonQueries(current, previous, options, comparisonFilter, comparisonOrderBy, windowCount) {
 	const { adapter, siteId, searchType } = options;
 	const comparisonPlan = buildComparisonPlan(current, previous, adapter.capabilities);
 	const currentScope = buildScope(current, options);
@@ -295,12 +367,18 @@ function resolveComparisonSQL(current, previous, options, comparisonFilter, comp
 	outerCurrentCols.push(sql.raw("COALESCE(c.ctr, 0) as \"ctr\""));
 	outerCurrentCols.push(sql.raw("COALESCE(c.position, 0) as \"position\""));
 	if (changeOrder) outerCurrentCols.push(changeOrder.column);
-	const mainQuery = sql`WITH current AS (${currentCte}), previous AS (${previousCte}) SELECT ${joinComma(outerCurrentCols)}, COALESCE(CAST(p.clicks AS DOUBLE), 0) as "prevClicks", COALESCE(CAST(p.impressions AS DOUBLE), 0) as "prevImpressions", COALESCE(p.ctr, 0) as "prevCtr", COALESCE(p.position, 0) as "prevPosition" FROM current c FULL OUTER JOIN previous p ON ${joinOn} WHERE 1=1 ${filterClause} ${orderSql} ${limitSql}`;
+	const mainQuery = sql`WITH current AS (${currentCte}), previous AS (${previousCte}) SELECT ${joinComma(outerCurrentCols)}, COALESCE(CAST(p.clicks AS DOUBLE), 0) as "prevClicks", COALESCE(CAST(p.impressions AS DOUBLE), 0) as "prevImpressions", COALESCE(p.ctr, 0) as "prevCtr", COALESCE(p.position, 0) as "prevPosition"${windowCount ? sql.raw(", COUNT(*) OVER() as \"totalCount\"") : sql.raw("")} FROM current c FULL OUTER JOIN previous p ON ${joinOn} WHERE 1=1 ${filterClause} ${orderSql} ${limitSql}`;
 	const firstGroupBy = groupByDims[0] ? groupByDims[0].replace(/\W/g, "") : "clicks";
 	const countInnerSelect = groupByDims[0] ? sql.raw(`COALESCE(c.${firstGroupBy}, p.${firstGroupBy})`) : sql.raw(`c.${firstGroupBy}`);
-	const countQuery = sql`WITH current AS (${currentCte}), previous AS (${previousCte}) SELECT COUNT(*) as total FROM (SELECT ${countInnerSelect} FROM current c FULL OUTER JOIN previous p ON ${joinOn} WHERE 1=1 ${filterClause})`;
-	const main = compileCollapsed(adapter, mainQuery);
-	const count = compileCollapsed(adapter, countQuery);
+	return {
+		main: mainQuery,
+		count: sql`WITH current AS (${currentCte}), previous AS (${previousCte}) SELECT COUNT(*) as total FROM (SELECT ${countInnerSelect} FROM current c FULL OUTER JOIN previous p ON ${joinOn} WHERE 1=1 ${filterClause})`
+	};
+}
+function resolveComparisonSQL(current, previous, options, comparisonFilter, comparisonOrderBy) {
+	const queries = buildComparisonQueries(current, previous, options, comparisonFilter, comparisonOrderBy, false);
+	const main = compileCollapsed(options.adapter, queries.main);
+	const count = compileCollapsed(options.adapter, queries.count);
 	return {
 		sql: main.sql,
 		params: main.params,
@@ -308,6 +386,10 @@ function resolveComparisonSQL(current, previous, options, comparisonFilter, comp
 		countParams: count.params
 	};
 }
+function resolveComparisonSQLOptimized(current, previous, options, comparisonFilter, comparisonOrderBy) {
+	const queries = buildComparisonQueries(current, previous, options, comparisonFilter, comparisonOrderBy, true);
+	return compileCollapsed(options.adapter, queries.main);
+}
 function buildExtrasQueries(state, options, queryCanonicalKeys) {
 	const { adapter, siteId, searchType } = options;
 	const plan = buildLogicalPlan(state, adapter.capabilities);
@@ -407,4 +489,4 @@ function mergeExtras(rows, extrasResults) {
 		return enriched;
 	});
 }
-export { buildExtrasQueries, buildTotalsSql, mergeExtras, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized };
+export { buildComparisonTotalsSql, buildExtrasQueries, buildTotalsSql, mergeExtras, resolveComparisonSQL, resolveComparisonSQLOptimized, resolveToSQL, resolveToSQLOptimized, splitComparisonTotalsRow };

package/dist/resolver/index.d.mts

@@ -1,12 +1,12 @@
-import { ComparisonFilter, ComparisonOrderBy, ExtraQuery, ResolvedComparisonSQL, ResolvedSQL, ResolvedSQLOptimized, ResolverAdapter, ResolverOptions } from "./types.mjs";
+import { ComparisonFilter, ComparisonOrderBy, ExtraQuery, ResolvedComparisonSQL, ResolvedComparisonTotalsSQL, ResolvedSQL, ResolvedSQLOptimized, ResolverAdapter, ResolverOptions } from "./types.mjs";
 import { DIMENSION_SURFACES, DimensionBinding, DimensionSurface, LOGICAL_DATASETS, LogicalDataset, LogicalDatasetDefinition, UnresolvableDatasetError, assertDimensionsSupported, dimensionColumn, inferLogicalDataset, isDatasetResolvable, supportsDimensionOnSurface } from "./datasets.mjs";
 import { SqlFragments, SqlFragmentsConfig, createSqlFragments } from "./fragments.mjs";
 import { CreateResolverAdapterConfig, createResolverAdapter } from "./adapter.mjs";
 import { canonicalRollupCovers } from "./canonical-source.mjs";
-import { buildExtrasQueries, buildTotalsSql, mergeExtras, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized } from "./compile.mjs";
+import { buildComparisonTotalsSql, buildExtrasQueries, buildTotalsSql, mergeExtras, resolveComparisonSQL, resolveComparisonSQLOptimized, resolveToSQL, resolveToSQLOptimized, splitComparisonTotalsRow } from "./compile.mjs";
 import { CanonicalQueryDimSource, ComparisonQueryResult, OptimizedQueryResult, PrimaryColumnarSource, QuerySourceCoverageError, QuerySourceDecision, QuerySourceFallback, QuerySourceFallbackKind, QuerySourceKind, ResolveExtraFn, RunOptimizedQueryOptions, RunQueryCtx, RunSQLFn, runComparisonQuery, runOptimizedQuery } from "./run-query.mjs";
 import { RollupRowsReader, createRollupExtrasOverlay } from "./extras-overlay.mjs";
 import { dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, metricValue } from "./filter-utils.mjs";
 import { PgTableKey, R2SqlResolverAdapterOptions, ResolverAdapterOptions, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, pgResolverAdapter } from "./pg-adapter.mjs";
 import { AssertSchemaInSyncOptions, assertSchemaInSync } from "./schema-drift.mjs";
-export { type AssertSchemaInSyncOptions, type CanonicalQueryDimSource, type ComparisonFilter, type ComparisonOrderBy, type ComparisonQueryResult, type CreateResolverAdapterConfig, DIMENSION_SURFACES, type DimensionBinding, type DimensionSurface, type ExtraQuery, LOGICAL_DATASETS, type LogicalDataset, type LogicalDatasetDefinition, type OptimizedQueryResult, type PgTableKey, type PrimaryColumnarSource, QuerySourceCoverageError, type QuerySourceDecision, type QuerySourceFallback, type QuerySourceFallbackKind, type QuerySourceKind, type R2SqlResolverAdapterOptions, type ResolveExtraFn, type ResolvedComparisonSQL, type ResolvedSQL, type ResolvedSQLOptimized, type ResolverAdapter, type ResolverAdapterOptions, type ResolverOptions, type RollupRowsReader, type RunOptimizedQueryOptions, type RunQueryCtx, type RunSQLFn, type SqlFragments, type SqlFragmentsConfig, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };
+export { type AssertSchemaInSyncOptions, type CanonicalQueryDimSource, type ComparisonFilter, type ComparisonOrderBy, type ComparisonQueryResult, type CreateResolverAdapterConfig, DIMENSION_SURFACES, type DimensionBinding, type DimensionSurface, type ExtraQuery, LOGICAL_DATASETS, type LogicalDataset, type LogicalDatasetDefinition, type OptimizedQueryResult, type PgTableKey, type PrimaryColumnarSource, QuerySourceCoverageError, type QuerySourceDecision, type QuerySourceFallback, type QuerySourceFallbackKind, type QuerySourceKind, type R2SqlResolverAdapterOptions, type ResolveExtraFn, type ResolvedComparisonSQL, type ResolvedComparisonTotalsSQL, type ResolvedSQL, type ResolvedSQLOptimized, type ResolverAdapter, type ResolverAdapterOptions, type ResolverOptions, type RollupRowsReader, type RunOptimizedQueryOptions, type RunQueryCtx, type RunSQLFn, type SqlFragments, type SqlFragmentsConfig, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildComparisonTotalsSql, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveComparisonSQLOptimized, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, splitComparisonTotalsRow, supportsDimensionOnSurface };

package/dist/resolver/index.mjs

@@ -2,10 +2,10 @@ import { DIMENSION_SURFACES, LOGICAL_DATASETS, UnresolvableDatasetError, assertD
 import { createSqlFragments } from "./fragments.mjs";
 import { createResolverAdapter } from "./adapter.mjs";
 import { canonicalRollupCovers } from "./canonical-source.mjs";
-import { buildExtrasQueries, buildTotalsSql, mergeExtras, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized } from "./compile.mjs";
+import { buildComparisonTotalsSql, buildExtrasQueries, buildTotalsSql, mergeExtras, resolveComparisonSQL, resolveComparisonSQLOptimized, resolveToSQL, resolveToSQLOptimized, splitComparisonTotalsRow } from "./compile.mjs";
 import { createRollupExtrasOverlay } from "./extras-overlay.mjs";
 import { dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, metricValue } from "./filter-utils.mjs";
 import { createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, pgResolverAdapter } from "./pg-adapter.mjs";
 import { QuerySourceCoverageError, runComparisonQuery, runOptimizedQuery } from "./run-query.mjs";
 import { assertSchemaInSync } from "./schema-drift.mjs";
-export { DIMENSION_SURFACES, LOGICAL_DATASETS, QuerySourceCoverageError, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };
+export { DIMENSION_SURFACES, LOGICAL_DATASETS, QuerySourceCoverageError, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildComparisonTotalsSql, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveComparisonSQLOptimized, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, splitComparisonTotalsRow, supportsDimensionOnSurface };

package/dist/resolver/types.d.mts

@@ -74,6 +74,20 @@ export interface ResolvedComparisonSQL {
   countSql: string;
   countParams: unknown[];
 }
+/**
+ * Totals SQL for the current and previous windows of a comparison read.
+ * `Combined` is one statement for both windows. `Separate` is one statement
+ * per window, for windows that read different tables or filter different rows.
+ */
+export type ResolvedComparisonTotalsSQL = {
+  _tag: 'Combined';
+  sql: string;
+  params: unknown[];
+} | {
+  _tag: 'Separate';
+  current: ResolvedSQLOptimized;
+  previous: ResolvedSQLOptimized;
+};
 export interface ExtraQuery {
   key: string;
   sql: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/engine",
   "type": "module",
-  "version": "7.8.4",
+  "version": "7.9.0",
   "description": "Append-only Parquet/DuckDB storage engine + planner + adapters for the gscdump pipeline. Node + edge runtimes; opt-in heavy peers.",
   "author": {
     "name": "Harlan Wilton",
@@ -189,10 +189,10 @@
     }
   },
   "dependencies": {
-    "@gscdump/contracts": "^7.8.4",
-    "@gscdump/lakehouse": "^7.8.4",
+    "@gscdump/contracts": "^7.9.0",
+    "@gscdump/lakehouse": "^7.9.0",
     "drizzle-orm": "1.0.0-rc.4",
-    "gscdump": "^7.8.4",
+    "gscdump": "^7.9.0",
     "pathe": "^2.0.3",
     "proper-lockfile": "^4.1.2"
   },