@gscdump/engine-sqlite 1.4.0 → 1.4.1

package/dist/r2-manifest-schema.mjs

@@ -0,0 +1,81 @@
+import { sql } from "drizzle-orm";
+import { index, integer, primaryKey, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+const r2Manifest = sqliteTable("r2_manifest", {
+	id: text("id").primaryKey(),
+	userId: integer("user_id").notNull(),
+	siteId: text("site_id"),
+	table: text("table").notNull(),
+	partition: text("partition").notNull(),
+	objectKey: text("object_key").notNull(),
+	rowCount: integer("row_count").notNull().default(0),
+	bytes: integer("bytes").notNull().default(0),
+	createdAt: integer("created_at").notNull(),
+	retiredAt: integer("retired_at"),
+	tier: text("tier"),
+	searchType: text("search_type"),
+	schemaVersion: integer("schema_version")
+}, (t) => [
+	index("idx_r2_manifest_live").on(t.userId, t.siteId, t.table, t.partition, t.retiredAt),
+	index("idx_r2_manifest_lookup").on(t.userId, t.siteId, t.table, t.searchType, t.tier, t.partition, t.retiredAt),
+	index("idx_r2_manifest_retired").on(t.retiredAt),
+	index("idx_r2_manifest_tier").on(t.userId, t.siteId, t.table, t.tier, t.retiredAt),
+	unique("r2_manifest_object_key_unique").on(t.objectKey)
+]);
+const r2WriteErrors = sqliteTable("r2_write_errors", {
+	id: text("id").primaryKey(),
+	userId: integer("user_id").notNull(),
+	siteId: text("site_id"),
+	table: text("table"),
+	date: text("date"),
+	error: text("error").notNull(),
+	createdAt: integer("created_at").notNull().default(sql`(unixepoch())`)
+}, (t) => [index("idx_r2_write_errors_user").on(t.userId, t.createdAt), index("idx_r2_write_errors_created").on(t.createdAt)]);
+const r2ShadowDiffs = sqliteTable("r2_shadow_diffs", {
+	id: text("id").primaryKey(),
+	userId: integer("user_id").notNull(),
+	siteId: text("site_id"),
+	endpoint: text("endpoint").notNull(),
+	diff: text("diff").notNull(),
+	createdAt: integer("created_at").notNull().default(sql`(unixepoch())`)
+}, (t) => [index("idx_r2_shadow_diffs_user").on(t.userId, t.createdAt), index("idx_r2_shadow_diffs_endpoint").on(t.endpoint, t.createdAt)]);
+const r2Locks = sqliteTable("r2_locks", {
+	scope: text("scope").primaryKey(),
+	holderId: text("holder_id").notNull(),
+	acquiredAt: integer("acquired_at").notNull(),
+	expiresAt: integer("expires_at").notNull()
+}, (t) => [index("idx_r2_locks_expires").on(t.expiresAt)]);
+const r2Watermarks = sqliteTable("r2_watermarks", {
+	userId: integer("user_id").notNull(),
+	siteId: text("site_id").notNull().default(""),
+	table: text("table").notNull(),
+	newestDateSynced: text("newest_date_synced").notNull(),
+	oldestDateSynced: text("oldest_date_synced").notNull(),
+	lastSyncAt: integer("last_sync_at").notNull()
+}, (t) => [primaryKey({ columns: [
+	t.userId,
+	t.siteId,
+	t.table
+] })]);
+const r2SyncStates = sqliteTable("r2_sync_states", {
+	userId: integer("user_id").notNull(),
+	siteId: text("site_id").notNull().default(""),
+	table: text("table").notNull(),
+	date: text("date").notNull(),
+	searchType: text("search_type").notNull().default(""),
+	state: text("state", { enum: [
+		"pending",
+		"inflight",
+		"done",
+		"failed"
+	] }).notNull(),
+	updatedAt: integer("updated_at").notNull(),
+	attempts: integer("attempts").notNull().default(0),
+	error: text("error")
+}, (t) => [primaryKey({ columns: [
+	t.userId,
+	t.siteId,
+	t.table,
+	t.date,
+	t.searchType
+] }), index("idx_r2_sync_states_state").on(t.state)]);
+export { r2Locks, r2Manifest, r2ShadowDiffs, r2SyncStates, r2Watermarks, r2WriteErrors };

package/dist/r2-manifest-store.d.mts

@@ -0,0 +1,11 @@
+import { r2Locks, r2Manifest, r2SyncStates, r2Watermarks } from "./r2-manifest-schema.mjs";
+import { ManifestStore } from "@gscdump/engine";
+import { DrizzleD1Database } from "drizzle-orm/d1";
+type AnalyticsManifestDb = DrizzleD1Database<{
+  r2Manifest: typeof r2Manifest;
+  r2Locks: typeof r2Locks;
+  r2SyncStates: typeof r2SyncStates;
+  r2Watermarks: typeof r2Watermarks;
+}>;
+declare function createD1ManifestStore(db: AnalyticsManifestDb): ManifestStore;
+export { AnalyticsManifestDb, createD1ManifestStore };

package/dist/r2-manifest-store.mjs

@@ -0,0 +1,282 @@
+import { r2Locks, r2Manifest, r2SyncStates, r2Watermarks } from "./r2-manifest-schema.mjs";
+import { and, eq, inArray, isNotNull, isNull, lt, lte, or, sql } from "drizzle-orm";
+import { inferSearchType } from "@gscdump/engine";
+import { engineErrorToException, engineErrors } from "@gscdump/engine/errors";
+function toRow(e) {
+	return {
+		id: e.objectKey,
+		userId: Number(e.userId),
+		siteId: e.siteId ?? null,
+		table: e.table,
+		partition: e.partition,
+		objectKey: e.objectKey,
+		rowCount: e.rowCount,
+		bytes: e.bytes,
+		createdAt: e.createdAt,
+		retiredAt: e.retiredAt ?? null,
+		tier: e.tier ?? null,
+		searchType: e.searchType ?? null,
+		schemaVersion: e.schemaVersion ?? null
+	};
+}
+function fromRow(r) {
+	return {
+		userId: String(r.userId),
+		siteId: r.siteId ?? void 0,
+		table: r.table,
+		partition: r.partition,
+		objectKey: r.objectKey,
+		rowCount: r.rowCount,
+		bytes: r.bytes,
+		createdAt: r.createdAt,
+		retiredAt: r.retiredAt ?? void 0,
+		...r.tier !== null ? { tier: r.tier } : {},
+		...r.searchType !== null ? { searchType: r.searchType } : {},
+		...r.schemaVersion !== null ? { schemaVersion: r.schemaVersion } : {}
+	};
+}
+const siteIdOf = (s) => s ?? "";
+const searchTypeOf = (s) => s === void 0 || s === "web" ? "" : s;
+const LOCK_TTL_MS = 3e4;
+const LOCK_ACQUIRE_TIMEOUT_MS = 5e3;
+const LOCK_RETRY_MIN_MS = 25;
+const LOCK_RETRY_MAX_MS = 150;
+const D1_BATCH_LIMIT = 95;
+const D1_IN_CLAUSE_CHUNK = 90;
+function lockScopeKey(scope) {
+	return `${scope.userId}|${siteIdOf(scope.siteId)}|${scope.table}|${scope.partition}`;
+}
+function jitterDelay() {
+	return LOCK_RETRY_MIN_MS + Math.floor(Math.random() * (LOCK_RETRY_MAX_MS - LOCK_RETRY_MIN_MS));
+}
+function tierMatchCond(target) {
+	const explicit = eq(r2Manifest.tier, target);
+	if (target === "raw") return or(explicit, and(isNull(r2Manifest.tier), sql`${r2Manifest.partition} LIKE 'daily/%'`));
+	if (target === "d30") return or(explicit, and(isNull(r2Manifest.tier), sql`${r2Manifest.partition} LIKE 'monthly/%'`));
+	return explicit;
+}
+function createD1ManifestStore(db) {
+	async function listByFilter(filter, liveOnly) {
+		const baseConds = [eq(r2Manifest.userId, Number(filter.userId))];
+		if (liveOnly) baseConds.push(isNull(r2Manifest.retiredAt));
+		if (filter.siteId !== void 0) baseConds.push(eq(r2Manifest.siteId, filter.siteId));
+		if (filter.table !== void 0) baseConds.push(eq(r2Manifest.table, filter.table));
+		if (filter.tier !== void 0) {
+			const cond = tierMatchCond(filter.tier);
+			if (cond) baseConds.push(cond);
+		}
+		if (filter.searchType !== void 0) baseConds.push(filter.searchType === "web" ? or(eq(r2Manifest.searchType, "web"), isNull(r2Manifest.searchType)) : eq(r2Manifest.searchType, filter.searchType));
+		const PARTITION_CHUNK = 80;
+		if (filter.partitions) {
+			if (filter.partitions.length === 0) return [];
+			const statements = [];
+			for (let i = 0; i < filter.partitions.length; i += PARTITION_CHUNK) {
+				const slice = filter.partitions.slice(i, i + PARTITION_CHUNK);
+				const conds = [...baseConds, inArray(r2Manifest.partition, slice)];
+				statements.push(db.select().from(r2Manifest).where(and(...conds)));
+			}
+			return (await db.batch(statements)).flat().map((r) => fromRow(r));
+		}
+		return (await db.select().from(r2Manifest).where(and(...baseConds))).map(fromRow);
+	}
+	const listLive = (filter) => listByFilter(filter, true);
+	const listAll = (filter) => listByFilter(filter, false);
+	async function registerVersions(newEntries, superseding) {
+		const supersededAt = newEntries[0]?.createdAt ?? Date.now();
+		const statements = [];
+		if (superseding && superseding.length > 0) {
+			const keys = superseding.map((s) => s.objectKey);
+			for (let i = 0; i < keys.length; i += D1_IN_CLAUSE_CHUNK) {
+				const slice = keys.slice(i, i + D1_IN_CLAUSE_CHUNK);
+				statements.push(db.update(r2Manifest).set({ retiredAt: supersededAt }).where(and(inArray(r2Manifest.objectKey, slice), isNull(r2Manifest.retiredAt))));
+			}
+		}
+		for (const e of newEntries) statements.push(db.insert(r2Manifest).values(toRow(e)).onConflictDoUpdate({
+			target: r2Manifest.objectKey,
+			set: {
+				userId: sql`excluded.user_id`,
+				siteId: sql`excluded.site_id`,
+				table: sql`excluded."table"`,
+				partition: sql`excluded.partition`,
+				rowCount: sql`excluded.row_count`,
+				bytes: sql`excluded.bytes`,
+				createdAt: sql`excluded.created_at`,
+				retiredAt: sql`excluded.retired_at`,
+				tier: sql`excluded.tier`,
+				searchType: sql`excluded.search_type`,
+				schemaVersion: sql`excluded.schema_version`
+			}
+		}));
+		if (statements.length === 0) return;
+		for (let i = 0; i < statements.length; i += D1_BATCH_LIMIT) {
+			const chunk = statements.slice(i, i + D1_BATCH_LIMIT);
+			await db.batch(chunk);
+		}
+	}
+	async function listRetired(olderThan) {
+		return (await db.select().from(r2Manifest).where(and(isNotNull(r2Manifest.retiredAt), lte(r2Manifest.retiredAt, olderThan)))).map(fromRow);
+	}
+	async function deleteEntries(entries) {
+		if (entries.length === 0) return;
+		const keys = entries.map((e) => e.objectKey);
+		const statements = [];
+		for (let i = 0; i < keys.length; i += D1_IN_CLAUSE_CHUNK) statements.push(db.delete(r2Manifest).where(inArray(r2Manifest.objectKey, keys.slice(i, i + D1_IN_CLAUSE_CHUNK))));
+		for (let i = 0; i < statements.length; i += D1_BATCH_LIMIT) await db.batch(statements.slice(i, i + D1_BATCH_LIMIT));
+	}
+	async function getWatermarks(filter) {
+		const conds = [eq(r2Watermarks.userId, Number(filter.userId))];
+		if (filter.siteId !== void 0) conds.push(eq(r2Watermarks.siteId, filter.siteId));
+		if (filter.table !== void 0) conds.push(eq(r2Watermarks.table, filter.table));
+		return (await db.select().from(r2Watermarks).where(and(...conds))).map((r) => ({
+			userId: String(r.userId),
+			siteId: r.siteId === "" ? void 0 : r.siteId,
+			table: r.table,
+			newestDateSynced: r.newestDateSynced,
+			oldestDateSynced: r.oldestDateSynced,
+			lastSyncAt: r.lastSyncAt
+		}));
+	}
+	async function bumpWatermark(scope, date, at) {
+		const lastSyncAt = at ?? Date.now();
+		await db.insert(r2Watermarks).values({
+			userId: Number(scope.userId),
+			siteId: siteIdOf(scope.siteId),
+			table: scope.table,
+			newestDateSynced: date,
+			oldestDateSynced: date,
+			lastSyncAt
+		}).onConflictDoUpdate({
+			target: [
+				r2Watermarks.userId,
+				r2Watermarks.siteId,
+				r2Watermarks.table
+			],
+			set: {
+				newestDateSynced: sql`CASE WHEN excluded.newest_date_synced > newest_date_synced THEN excluded.newest_date_synced ELSE newest_date_synced END`,
+				oldestDateSynced: sql`CASE WHEN excluded.oldest_date_synced < oldest_date_synced THEN excluded.oldest_date_synced ELSE oldest_date_synced END`,
+				lastSyncAt: sql`CASE WHEN excluded.last_sync_at > last_sync_at THEN excluded.last_sync_at ELSE last_sync_at END`
+			}
+		}).run();
+	}
+	async function getSyncStates(filter) {
+		const conds = [eq(r2SyncStates.userId, Number(filter.userId))];
+		if (filter.siteId !== void 0) conds.push(eq(r2SyncStates.siteId, filter.siteId));
+		if (filter.table !== void 0) conds.push(eq(r2SyncStates.table, filter.table));
+		if (filter.state !== void 0) conds.push(eq(r2SyncStates.state, filter.state));
+		if (filter.searchType !== void 0) conds.push(eq(r2SyncStates.searchType, searchTypeOf(filter.searchType)));
+		return (await db.select().from(r2SyncStates).where(and(...conds))).map((r) => ({
+			userId: String(r.userId),
+			siteId: r.siteId === "" ? void 0 : r.siteId,
+			table: r.table,
+			date: r.date,
+			searchType: inferSearchType({ searchType: r.searchType === "" ? void 0 : r.searchType }),
+			state: r.state,
+			updatedAt: r.updatedAt,
+			attempts: r.attempts,
+			error: r.error ?? void 0
+		}));
+	}
+	async function setSyncState(scope, state, detail) {
+		const updatedAt = detail?.at ?? Date.now();
+		const errorText = detail?.error ?? null;
+		await db.insert(r2SyncStates).values({
+			userId: Number(scope.userId),
+			siteId: siteIdOf(scope.siteId),
+			table: scope.table,
+			date: scope.date,
+			searchType: searchTypeOf(scope.searchType),
+			state,
+			updatedAt,
+			attempts: state === "inflight" ? 1 : 0,
+			error: errorText
+		}).onConflictDoUpdate({
+			target: [
+				r2SyncStates.userId,
+				r2SyncStates.siteId,
+				r2SyncStates.table,
+				r2SyncStates.date,
+				r2SyncStates.searchType
+			],
+			set: {
+				state: sql`excluded.state`,
+				updatedAt: sql`excluded.updated_at`,
+				attempts: sql`CASE WHEN excluded.state = 'inflight' THEN attempts + 1 ELSE attempts END`,
+				error: sql`CASE
+          WHEN excluded.state = 'done' THEN NULL
+          WHEN excluded.state = 'inflight' THEN error
+          ELSE excluded.error
+        END`
+			}
+		}).run();
+	}
+	async function withLock(scope, fn) {
+		const key = lockScopeKey(scope);
+		const holderId = crypto.randomUUID();
+		const deadline = Date.now() + LOCK_ACQUIRE_TIMEOUT_MS;
+		while (true) {
+			const now = Date.now();
+			const expiresAt = now + LOCK_TTL_MS;
+			await db.insert(r2Locks).values({
+				scope: key,
+				holderId,
+				acquiredAt: now,
+				expiresAt
+			}).onConflictDoUpdate({
+				target: r2Locks.scope,
+				set: {
+					holderId: sql`excluded.holder_id`,
+					acquiredAt: sql`excluded.acquired_at`,
+					expiresAt: sql`excluded.expires_at`
+				},
+				setWhere: lt(r2Locks.expiresAt, now)
+			}).run();
+			if ((await db.select({ holderId: r2Locks.holderId }).from(r2Locks).where(eq(r2Locks.scope, key)).get())?.holderId === holderId) break;
+			if (Date.now() >= deadline) throw engineErrorToException(engineErrors.lockAcquireTimeout(key, LOCK_ACQUIRE_TIMEOUT_MS));
+			await new Promise((resolve) => setTimeout(resolve, jitterDelay()));
+		}
+		return await fn().finally(async () => {
+			await Promise.resolve(db.delete(r2Locks).where(and(eq(r2Locks.scope, key), eq(r2Locks.holderId, holderId))).run()).catch((error) => {
+				console.warn(`[gscdump/engine-sqlite] failed to release manifest lock ${key}; lease will expire`, error);
+			});
+		});
+	}
+	async function purgeTenant(filter) {
+		const userIdNum = Number(filter.userId);
+		const entriesCond = filter.siteId !== void 0 ? and(eq(r2Manifest.userId, userIdNum), eq(r2Manifest.siteId, filter.siteId)) : eq(r2Manifest.userId, userIdNum);
+		const watermarksCond = filter.siteId !== void 0 ? and(eq(r2Watermarks.userId, userIdNum), eq(r2Watermarks.siteId, filter.siteId)) : eq(r2Watermarks.userId, userIdNum);
+		const syncStatesCond = filter.siteId !== void 0 ? and(eq(r2SyncStates.userId, userIdNum), eq(r2SyncStates.siteId, filter.siteId)) : eq(r2SyncStates.userId, userIdNum);
+		const [entriesRows, watermarkRows, syncStateRows] = await Promise.all([
+			db.select({ n: sql`count(*)` }).from(r2Manifest).where(entriesCond).all(),
+			db.select({ n: sql`count(*)` }).from(r2Watermarks).where(watermarksCond).all(),
+			db.select({ n: sql`count(*)` }).from(r2SyncStates).where(syncStatesCond).all()
+		]);
+		const entriesRemoved = Number(entriesRows[0]?.n ?? 0);
+		const watermarksRemoved = Number(watermarkRows[0]?.n ?? 0);
+		const syncStatesRemoved = Number(syncStateRows[0]?.n ?? 0);
+		await db.batch([
+			db.delete(r2Manifest).where(entriesCond),
+			db.delete(r2Watermarks).where(watermarksCond),
+			db.delete(r2SyncStates).where(syncStatesCond)
+		]);
+		return {
+			entriesRemoved,
+			watermarksRemoved,
+			syncStatesRemoved
+		};
+	}
+	return {
+		listLive,
+		listAll,
+		registerVersion: (entry, superseding) => registerVersions([entry], superseding),
+		registerVersions,
+		listRetired,
+		delete: deleteEntries,
+		getWatermarks,
+		bumpWatermark,
+		getSyncStates,
+		setSyncState,
+		withLock,
+		purgeTenant
+	};
+}
+export { createD1ManifestStore };

package/dist/resolver-adapter.d.mts

@@ -0,0 +1,27 @@
+import { schema } from "./schema.mjs";
+import { SqliteRowExecutor } from "./runner.mjs";
+import { ResolverAdapter } from "@gscdump/engine/resolver";
+type TableKey = keyof typeof schema;
+interface CreateSqliteResolverAdapterOptions {
+  regex?: boolean;
+}
+declare function createSqliteResolverAdapter(options?: CreateSqliteResolverAdapterOptions): ResolverAdapter<TableKey>;
+declare const sqliteResolverAdapter: ResolverAdapter<"gsc_countries" | "gsc_devices" | "gsc_hourly_pages" | "gsc_keywords" | "gsc_page_keywords" | "gsc_pages" | "gsc_query_dim" | "gsc_search_appearance" | "gsc_search_appearance_page_queries" | "gsc_search_appearance_pages" | "gsc_search_appearance_queries">;
+/**
+ * One-shot probe that detects whether the host SQLite has a working REGEXP
+ * function. SQLite ships REGEXP as a no-op stub by default; D1, libsql, and
+ * sqlite3 with the regexp extension register a real implementation. Probe
+ * once at adapter construction so per-query plan-time gating is honest.
+ */
+declare function probeSqliteRegex(executor: SqliteRowExecutor): Promise<boolean>;
+interface CreateSqliteResolverAdapterFromExecutorOptions {
+  executor: SqliteRowExecutor;
+}
+/**
+ * Async factory that probes REGEXP availability on `executor` and returns
+ * a resolver adapter with `capabilities.regex` set accordingly. Prefer over
+ * the manual `createSqliteResolverAdapter({ regex })` whenever you have
+ * an executor handy.
+ */
+declare function createSqliteResolverAdapterFromExecutor(options: CreateSqliteResolverAdapterFromExecutorOptions): Promise<ResolverAdapter<TableKey>>;
+export { CreateSqliteResolverAdapterFromExecutorOptions, CreateSqliteResolverAdapterOptions, TableKey, createSqliteResolverAdapter, createSqliteResolverAdapterFromExecutor, probeSqliteRegex, sqliteResolverAdapter };

package/dist/resolver-adapter.mjs

@@ -0,0 +1,41 @@
+import { schema } from "./schema.mjs";
+import { compileSqlite } from "./runner.mjs";
+import { sql } from "drizzle-orm";
+import { createResolverAdapter } from "@gscdump/engine/resolver";
+function createSqliteResolverAdapter(options = {}) {
+	return createResolverAdapter({
+		schema,
+		datasetToTableKey: {
+			pages: "gsc_pages",
+			queries: "gsc_keywords",
+			page_queries: "gsc_page_keywords",
+			countries: "gsc_countries",
+			dates: "gsc_devices",
+			search_appearance: "gsc_search_appearance",
+			search_appearance_pages: "gsc_search_appearance_pages",
+			search_appearance_queries: "gsc_search_appearance_queries",
+			search_appearance_page_queries: "gsc_search_appearance_page_queries",
+			hourly_pages: "gsc_hourly_pages"
+		},
+		metricCast: "REAL",
+		regexPredicate: (expr, pattern, negate) => negate ? sql`NOT (${expr} REGEXP ${pattern})` : sql`${expr} REGEXP ${pattern}`,
+		tableLabel: "sqlite/resolver-adapter",
+		includeSiteId: true,
+		queryDimTableRef: () => sql.raw("\"gsc_query_dim\" AS \"query_dim\""),
+		queryDimSiteScoped: true,
+		compile: compileSqlite,
+		capabilities: {
+			regex: options.regex ?? false,
+			comparisonJoin: true,
+			windowTotals: true
+		}
+	});
+}
+const sqliteResolverAdapter = createSqliteResolverAdapter();
+async function probeSqliteRegex(executor) {
+	return executor(`SELECT 'a' REGEXP 'a' AS r`, [], "all").then(({ rows }) => rows.length > 0).catch(() => false);
+}
+async function createSqliteResolverAdapterFromExecutor(options) {
+	return createSqliteResolverAdapter({ regex: await probeSqliteRegex(options.executor) });
+}
+export { createSqliteResolverAdapter, createSqliteResolverAdapterFromExecutor, probeSqliteRegex, sqliteResolverAdapter };

package/dist/runner.d.mts

@@ -0,0 +1,42 @@
+import { Schema } from "./schema.mjs";
+import { SQL } from "drizzle-orm";
+import { ScopedRunnerOptions, TableScope } from "@gscdump/engine/scope";
+import { SqliteRemoteDatabase } from "drizzle-orm/sqlite-proxy";
+declare function compileSqlite(query: SQL): {
+  sql: string;
+  params: unknown[];
+};
+type SqliteRowExecutor = (sql: string, params: unknown[], method: 'run' | 'all' | 'values' | 'get') => Promise<{
+  rows: unknown[];
+}>;
+interface SqliteInsightRunnerOptions<TSchema extends Record<string, unknown> = Schema> {
+  executor: SqliteRowExecutor;
+  logger?: boolean;
+  /**
+   * Convert object rows to positional arrays before handing to drizzle.
+   * D1 HTTP + most REST-style drivers return objects; set true when the
+   * executor yields `{ col: value }` rows.
+   */
+  rowsAsArrays?: boolean;
+  /**
+   * Override the bundled gsc_* schema. Pass an extended schema (superset
+   * of the upstream tables) when the consumer DB carries additional tables
+   * like sitemaps or indexing state. Defaults to the bundled schema.
+   */
+  schema?: TSchema;
+}
+interface SqliteInsightRunner<TSchema extends Record<string, unknown> = Schema> {
+  db: SqliteRemoteDatabase<TSchema>;
+}
+declare function createSqliteInsightRunner<TSchema extends Record<string, unknown> = Schema>(opts: SqliteInsightRunnerOptions<TSchema>): SqliteInsightRunner<TSchema>;
+/**
+ * Per-table predicate set from {siteId, window}. Unlike the /browser
+ * variant, every sqlite table has `site_id` so the siteId predicate is
+ * always emitted when supplied.
+ *
+ * Date bounds come from either a resolved window or bare startDate/endDate
+ * (one or both). This lets callers pass unbounded query-string params
+ * through without first normalizing them.
+ */
+declare const scopeFor: (table: "gsc_countries" | "gsc_devices" | "gsc_hourly_pages" | "gsc_keywords" | "gsc_page_keywords" | "gsc_pages" | "gsc_query_dim" | "gsc_search_appearance" | "gsc_search_appearance_page_queries" | "gsc_search_appearance_pages" | "gsc_search_appearance_queries", opts: ScopedRunnerOptions) => TableScope, mergeScope: typeof import("@gscdump/engine/scope").mergeScope;
+export { type ScopedRunnerOptions, SqliteInsightRunner, SqliteInsightRunnerOptions, SqliteRowExecutor, type TableScope, compileSqlite, createSqliteInsightRunner, mergeScope, scopeFor };

package/dist/runner.mjs

@@ -0,0 +1,30 @@
+import { schema } from "./schema.mjs";
+import { createScopedHelpers } from "@gscdump/engine/scope";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { drizzle } from "drizzle-orm/sqlite-proxy";
+const sqliteDialect = new SQLiteAsyncDialect();
+function compileSqlite(query) {
+	const compiled = sqliteDialect.sqlToQuery(query);
+	return {
+		sql: compiled.sql,
+		params: compiled.params
+	};
+}
+function createSqliteInsightRunner(opts) {
+	const { executor, logger, rowsAsArrays, schema: schemaOverride } = opts;
+	const callback = async (sql, params, method) => {
+		const result = await executor(sql, params, method);
+		if (!rowsAsArrays) return { rows: result.rows };
+		return { rows: result.rows.map((r) => {
+			if (Array.isArray(r)) return r;
+			if (r && typeof r === "object") return Object.values(r);
+			return r;
+		}) };
+	};
+	return { db: drizzle(callback, {
+		schema: schemaOverride ?? schema,
+		logger
+	}) };
+}
+const { scopeFor, mergeScope } = createScopedHelpers(schema);
+export { compileSqlite, createSqliteInsightRunner, mergeScope, scopeFor };