@gscdump/engine 0.9.2 → 0.11.0

package/README.md

@@ -33,7 +33,7 @@ Optional peers (install only what your runtime needs):
 | `@gscdump/engine/sql-fragments` | Reusable SQL fragments shared across analyzers. |
 | `@gscdump/engine/rollups` | Pre-aggregated rollup contracts + helpers. |
 | `@gscdump/engine/entities` | Entity helpers (sites, tenants, scope keys). |
-| `@gscdump/engine/resolver` | Dialect-neutral SQL composition: `ResolverAdapter`, `pgResolverAdapter`, `compilePg`/`compileSqlite`, `resolveToSQL`. |
+| `@gscdump/engine/resolver` | Dialect-neutral SQL composition: `ResolverAdapter`, `pgResolverAdapter`, `resolveToSQL`. |
 | `@gscdump/engine/scope` | Multi-tenant scope predicates. |
 | `@gscdump/engine/arrow` | Apache Arrow utilities for engine result conversion. |
 | `@gscdump/engine/node` | Node-only DuckDB handle. |

package/dist/_chunks/dispatch.mjs

@@ -6,26 +6,21 @@ var AnalyzerCapabilityError = class extends Error {
 		this.name = "AnalyzerCapabilityError";
 	}
 };
-function sourceCapabilities(source) {
-	const caps = /* @__PURE__ */ new Set();
-	if (source.executeSql) caps.add("executeSql");
-	if (source.capabilities.fileSets) caps.add("partitionedParquet");
-	if (source.capabilities.regex) caps.add("regex");
-	if (source.capabilities.windowTotals) caps.add("windowTotals");
-	if (source.capabilities.comparisonJoin) caps.add("comparisonJoin");
-	if (source.capabilities.attachedTables) caps.add("attachedTables");
-	return caps;
+function sourceHas(source, cap) {
+	return source.capabilities[cap] === true;
 }
-function assertSatisfies(analyzer, caps) {
-	const missing = analyzer.requires.filter((c) => !caps.has(c));
+function assertSatisfies(analyzer, source) {
+	const missing = analyzer.requires.filter((c) => !sourceHas(source, c));
 	if (missing.length > 0) throw new AnalyzerCapabilityError(analyzer.id, missing);
 }
 async function runAnalyzerFromSource(source, params, registry) {
-	const caps = sourceCapabilities(source);
-	const analyzer = registry.resolveAnalyzer(params.type, caps.has("executeSql") || caps.has("attachedTables"));
+	const analyzer = registry.resolveAnalyzer(params.type, sourceHas(source, "executeSql"));
 	if (!analyzer) throw new AnalyzerCapabilityError(params.type, ["executeSql"]);
-	assertSatisfies(analyzer, caps);
-	const plan = analyzer.build(params);
+	assertSatisfies(analyzer, source);
+	const plan = analyzer.build(params, {
+		adapter: source.adapter,
+		siteId: source.siteId
+	});
 	if (plan.kind === "rows") return runRowsPlanAgainstSource(source, analyzer, plan, params);
 	return runSqlPlanAgainstSource(source, analyzer, plan, params);
 }
@@ -50,7 +45,6 @@ function fileSetsFor(plan) {
 }
 async function runSqlPlanAgainstSource(source, analyzer, plan, params) {
 	if (!source.executeSql) throw new AnalyzerCapabilityError(analyzer.id, ["executeSql"]);
-	if (plan.requiresAttachedTables && !source.capabilities.attachedTables) throw new AnalyzerCapabilityError(analyzer.id, ["attachedTables"]);
 	const fileSets = source.capabilities.fileSets ? fileSetsFor(plan) : void 0;
 	const rows = await source.executeSql(plan.sql, plan.params, fileSets ? { fileSets } : void 0);
 	const extras = {};
@@ -62,7 +56,7 @@ async function runSqlPlanAgainstSource(source, analyzer, plan, params) {
 		params,
 		extras
 	});
-	const sourceMeta = source.capabilities.localSource ? { source: "local" } : source.capabilities.attachedTables ? { source: "browser" } : {};
+	const sourceMeta = source.kind ? { source: source.kind } : {};
 	return {
 		results,
 		meta: {

package/dist/_chunks/engine.mjs

@@ -0,0 +1,622 @@
+import { r as currentSchemaVersion, t as SCHEMAS } from "./schema.mjs";
+import { i as inferSearchType, n as dayPartition, s as objectKey, u as tenantPrefix } from "./storage.mjs";
+import { a as compactTieredImpl, i as substituteNamedFiles, n as compileLogicalQueryPlan, o as enumeratePartitions } from "./compiler.mjs";
+import { sqlEscape } from "../sql-bind.mjs";
+import { d as buildExtrasQueries, f as buildTotalsSql, g as resolveToSQLOptimized, m as resolveComparisonSQL, t as createParquetResolverAdapter } from "./pg-adapter.mjs";
+import { buildLogicalPlan } from "gscdump/query/plan";
+import { normalizeUrl } from "gscdump/normalize";
+async function encodeBytes(db, table, rows) {
+	const inName = db.makeTempPath("json");
+	const outName = db.makeTempPath("parquet");
+	const jsonBytes = new TextEncoder().encode(JSON.stringify(rows));
+	const registered = [];
+	await db.registerFileBuffer(inName, jsonBytes);
+	registered.push(inName);
+	try {
+		const sql = rows.length === 0 ? `COPY (SELECT * FROM ${emptyTableSchema(table)} WHERE FALSE) TO '${sqlEscape(outName)}' (FORMAT PARQUET)` : `COPY (SELECT * FROM read_json_auto('${sqlEscape(inName)}', format='array', columns=${columnsJson(table)})) TO '${sqlEscape(outName)}' (FORMAT PARQUET)`;
+		await db.query(sql);
+		registered.push(outName);
+		return await db.copyFileToBuffer(outName);
+	} finally {
+		await db.dropFiles(registered);
+	}
+}
+async function decodeBytes(db, bytes, table) {
+	const name = db.makeTempPath("parquet");
+	await db.registerFileBuffer(name, bytes);
+	try {
+		return await db.query(`SELECT * ${dateReplaceClause(table)} FROM read_parquet('${sqlEscape(name)}')`);
+	} finally {
+		await db.dropFiles([name]);
+	}
+}
+function createDuckDBCodec(factory) {
+	return {
+		async writeRows(ctx, rows, key, dataSource) {
+			const bytes = await encodeBytes(await factory.getDuckDB(), ctx.table, rows);
+			await dataSource.write(key, bytes);
+			return {
+				bytes: bytes.byteLength,
+				rowCount: rows.length
+			};
+		},
+		async readRows(ctx, key, dataSource) {
+			return decodeBytes(await factory.getDuckDB(), await dataSource.read(key), ctx.table);
+		},
+		async compactRows(ctx, inputKeys, outputKey, dataSource) {
+			const db = await factory.getDuckDB();
+			if (inputKeys.length === 0) {
+				const bytes = await encodeBytes(db, ctx.table, []);
+				await dataSource.write(outputKey, bytes);
+				return {
+					bytes: bytes.byteLength,
+					rowCount: 0
+				};
+			}
+			const inputUris = inputKeys.map((k) => dataSource.uri?.(k));
+			if (inputUris.every((u) => u !== void 0)) {
+				const outName = db.makeTempPath("parquet");
+				const fileList = inputUris.map((u) => `'${sqlEscape(u)}'`).join(", ");
+				try {
+					await db.query(`COPY (SELECT * FROM read_parquet([${fileList}], union_by_name=true)) TO '${sqlEscape(outName)}' (FORMAT PARQUET)`);
+					const bytes = await db.copyFileToBuffer(outName);
+					const countRows = await db.query(`SELECT count(*)::BIGINT AS n FROM read_parquet('${sqlEscape(outName)}')`);
+					const rowCount = Number(countRows[0]?.n ?? 0);
+					await dataSource.write(outputKey, bytes);
+					return {
+						bytes: bytes.byteLength,
+						rowCount
+					};
+				} finally {
+					await db.dropFiles([outName]);
+				}
+			}
+			const inputs = await Promise.all(inputKeys.map((k) => dataSource.read(k)));
+			const inNames = [];
+			const outName = db.makeTempPath("parquet");
+			const registered = [];
+			for (let i = 0; i < inputs.length; i++) {
+				const name = db.makeTempPath("parquet");
+				await db.registerFileBuffer(name, inputs[i]);
+				inNames.push(name);
+				registered.push(name);
+			}
+			try {
+				const fileList = inNames.map((n) => `'${sqlEscape(n)}'`).join(", ");
+				await db.query(`COPY (SELECT * FROM read_parquet([${fileList}], union_by_name = true)) TO '${sqlEscape(outName)}' (FORMAT PARQUET)`);
+				registered.push(outName);
+				const bytes = await db.copyFileToBuffer(outName);
+				const countRows = await db.query(`SELECT count(*)::BIGINT AS n FROM read_parquet('${sqlEscape(outName)}')`);
+				const rowCount = Number(countRows[0]?.n ?? 0);
+				await dataSource.write(outputKey, bytes);
+				return {
+					bytes: bytes.byteLength,
+					rowCount
+				};
+			} finally {
+				await db.dropFiles(registered);
+			}
+		}
+	};
+}
+function rewriteEmptyFileSets(sql, placeholders, defaultTable, placeholderTables) {
+	let out = sql;
+	for (const [name, keys] of Object.entries(placeholders)) {
+		if (keys.length > 0) continue;
+		const emptyFallback = `(SELECT * FROM ${emptyTableSchema(placeholderTables?.[name] ?? defaultTable)} WHERE FALSE)`;
+		const pattern = new RegExp(`read_parquet\\(\\s*\\{\\{${name}\\}\\}\\s*(?:,\\s*union_by_name\\s*=\\s*true\\s*)?\\)`, "g");
+		out = out.replace(pattern, emptyFallback);
+	}
+	return out;
+}
+function createDuckDBExecutor(factory) {
+	return { async execute({ sql, params, fileKeys, placeholderTables, dataSource, table, signal }) {
+		signal?.throwIfAborted();
+		const db = await factory.getDuckDB();
+		const placeholders = {};
+		const registered = [];
+		for (const [name, keys] of Object.entries(fileKeys)) {
+			const resolved = [];
+			for (const key of keys) {
+				const uri = dataSource.uri?.(key);
+				if (uri !== void 0) resolved.push(uri);
+				else {
+					const bytes = await dataSource.read(key, void 0, signal);
+					await db.registerFileBuffer(key, bytes);
+					registered.push(key);
+					resolved.push(key);
+				}
+			}
+			placeholders[name] = resolved;
+		}
+		try {
+			signal?.throwIfAborted();
+			const finalSql = substituteNamedFiles(rewriteEmptyFileSets(sql, placeholders, table, placeholderTables), placeholders);
+			return {
+				rows: await db.query(finalSql, params),
+				sql: finalSql
+			};
+		} finally {
+			if (registered.length > 0) await db.dropFiles(registered);
+		}
+	} };
+}
+function emptyTableSchema(table) {
+	return `(FROM (VALUES ${placeholderValues(table)}) t(${columnList(table)}))`;
+}
+function canonicalEmptyParquetSchema(table) {
+	return emptyTableSchema(table);
+}
+function dateReplaceClause(table) {
+	if (!table) return "";
+	const dateCols = SCHEMAS[table].columns.filter((c) => c.type === "DATE").map((c) => c.name);
+	if (dateCols.length === 0) return "";
+	return `REPLACE (${dateCols.map((n) => `strftime(${n}, '%Y-%m-%d') AS ${n}`).join(", ")})`;
+}
+function columnList(table) {
+	return SCHEMAS[table].columns.map((c) => c.name).join(", ");
+}
+function placeholderValues(table) {
+	return `(${SCHEMAS[table].columns.map((c) => defaultForType(c.type)).join(", ")})`;
+}
+function defaultForType(t) {
+	if (t === "VARCHAR") return "''";
+	if (t === "DATE") return "DATE '1970-01-01'";
+	if (t === "INTEGER" || t === "BIGINT") return "0";
+	if (t === "DOUBLE") return "CAST(0 AS DOUBLE)";
+	return "NULL";
+}
+function columnsJson(table) {
+	return `{${SCHEMAS[table].columns.map((c) => `'${c.name}': '${c.type}'`).join(", ")}}`;
+}
+const VERSION_RE = /__v(\d+)\.parquet$/;
+function parseLockScope(key) {
+	const match = VERSION_RE.exec(key);
+	if (!match) return void 0;
+	const parts = key.slice(0, match.index).split("/");
+	if (parts.length < 4) return void 0;
+	const userPart = parts[0];
+	if (!userPart.startsWith("u_")) return void 0;
+	const userId = userPart.slice(2);
+	const partition = parts.slice(-2).join("/");
+	const table = parts[parts.length - 3];
+	return {
+		userId,
+		siteId: parts.length >= 5 ? parts.slice(1, -3).join("/") : void 0,
+		table,
+		partition
+	};
+}
+async function gcOrphansImpl(deps, now, graceMs, opts = {}) {
+	const cutoff = now - graceMs;
+	const retired = await deps.manifestStore.listRetired(cutoff);
+	if (retired.length > 0) {
+		await deps.dataSource.delete(retired.map((e) => e.objectKey));
+		await deps.manifestStore.delete(retired);
+	}
+	let sweptOrphans = 0;
+	if (opts.userId) {
+		const prefix = tenantPrefix({
+			userId: opts.userId,
+			siteId: opts.siteId
+		});
+		const knownEntries = await deps.manifestStore.listAll({
+			userId: opts.userId,
+			siteId: opts.siteId
+		});
+		const knownSet = new Set(knownEntries.map((e) => e.objectKey));
+		const orphans = [];
+		const keyStream = deps.dataSource.streamList ? deps.dataSource.streamList(prefix) : async function* () {
+			const all = await deps.dataSource.list(prefix);
+			for (const k of all) yield k;
+		}();
+		for await (const key of keyStream) {
+			if (knownSet.has(key)) continue;
+			const match = VERSION_RE.exec(key);
+			if (!match) continue;
+			if (Number(match[1]) <= cutoff) orphans.push(key);
+		}
+		const byScope = /* @__PURE__ */ new Map();
+		for (const key of orphans) {
+			const scope = parseLockScope(key);
+			if (!scope) continue;
+			const sk = `${scope.userId}|${scope.siteId ?? ""}|${scope.table}|${scope.partition}`;
+			const bucket = byScope.get(sk) ?? {
+				scope,
+				keys: []
+			};
+			bucket.keys.push(key);
+			byScope.set(sk, bucket);
+		}
+		for (const { scope, keys } of byScope.values()) await deps.manifestStore.withLock(scope, async () => {
+			const known = await deps.manifestStore.listAll({
+				userId: scope.userId,
+				siteId: scope.siteId,
+				table: scope.table,
+				partitions: [scope.partition]
+			});
+			const knownInScope = new Set(known.map((e) => e.objectKey));
+			const stillOrphans = keys.filter((k) => !knownInScope.has(k));
+			if (stillOrphans.length > 0) {
+				await deps.dataSource.delete(stillOrphans);
+				sweptOrphans += stillOrphans.length;
+			}
+		});
+	}
+	return { deleted: retired.length + sweptOrphans };
+}
+const URL_PURGE_TABLES = ["pages", "page_keywords"];
+const MAX_DAY_BYTES = 100 * 1024 * 1024;
+const URL_COLUMNS = /* @__PURE__ */ new Set();
+for (const t of Object.keys(SCHEMAS)) for (const col of SCHEMAS[t].columns) if (col.name === "url") URL_COLUMNS.add(`${t}:url`);
+function normalizeRow(table, row) {
+	if (!URL_COLUMNS.has(`${table}:url`)) return row;
+	const url = row.url;
+	if (typeof url !== "string") return row;
+	const normalized = normalizeUrl(url);
+	if (normalized === url) return row;
+	return {
+		...row,
+		url: normalized
+	};
+}
+function createStorageEngine(opts) {
+	const { dataSource, manifestStore, codec, executor } = opts;
+	const defaultNow = opts.now ?? (() => Date.now());
+	async function writeDay(ctx, rows) {
+		if (!ctx.date) throw new Error("writeDay requires ctx.date");
+		const date = ctx.date;
+		const now = (ctx.now ?? defaultNow)();
+		const partition = dayPartition(date);
+		const searchType = ctx.searchType;
+		return manifestStore.withLock({
+			userId: ctx.userId,
+			siteId: ctx.siteId,
+			table: ctx.table,
+			partition
+		}, async () => {
+			const superseding = (await manifestStore.listLive({
+				userId: ctx.userId,
+				siteId: ctx.siteId,
+				table: ctx.table,
+				partitions: [partition]
+			})).filter((e) => inferSearchType(e) === inferSearchType({ searchType }));
+			const normalizedRows = rows.map((r) => normalizeRow(ctx.table, r));
+			const key = objectKey(ctx, ctx.table, partition, now, searchType);
+			const { bytes: writtenBytes, rowCount } = await codec.writeRows({ table: ctx.table }, normalizedRows, key, dataSource);
+			let bytes = writtenBytes;
+			if (bytes === 0 && rowCount > 0 && dataSource.head) {
+				const probed = await dataSource.head(key);
+				if (probed) bytes = probed.bytes;
+			}
+			if (bytes > 104857600) {
+				await dataSource.delete([key]).catch(() => {});
+				throw new Error(`writeDay payload ${bytes} bytes exceeds ${MAX_DAY_BYTES} hard ceiling (table=${ctx.table}, key=${key})`);
+			}
+			const entry = {
+				userId: ctx.userId,
+				siteId: ctx.siteId,
+				table: ctx.table,
+				partition,
+				objectKey: key,
+				rowCount,
+				bytes,
+				createdAt: now,
+				schemaVersion: currentSchemaVersion(ctx.table),
+				tier: "raw",
+				...searchType !== void 0 ? { searchType } : {}
+			};
+			await manifestStore.registerVersion(entry, superseding);
+			await manifestStore.bumpWatermark({
+				userId: ctx.userId,
+				siteId: ctx.siteId,
+				table: ctx.table
+			}, date, now);
+		});
+	}
+	async function runSQL(opts) {
+		opts.signal?.throwIfAborted();
+		const entries = Object.entries(opts.fileSets);
+		const perSet = await Promise.all(entries.map(async ([name, ref]) => {
+			return [name, (await manifestStore.listLive({
+				userId: opts.ctx.userId,
+				siteId: opts.ctx.siteId,
+				table: ref.table,
+				partitions: ref.partitions
+			})).map((e) => e.objectKey)];
+		}));
+		opts.signal?.throwIfAborted();
+		const fileKeys = {};
+		for (const [name, keys] of perSet) fileKeys[name] = keys;
+		const uniqueKeys = [...new Set(perSet.flatMap(([, keys]) => keys))];
+		let table = opts.table;
+		if (!table) {
+			if (new Set(entries.map(([, ref]) => ref.table)).size > 1) throw new Error("runSQL requires explicit ctx.table when fileSets reference multiple tables.");
+			table = entries[0]?.[1].table;
+		}
+		if (!table) throw new Error("runSQL requires at least one fileSet or an explicit table");
+		const placeholderTables = {};
+		for (const [name, ref] of entries) placeholderTables[name] = ref.table;
+		const result = await executor.execute({
+			sql: opts.sql,
+			params: opts.params ?? [],
+			fileKeys,
+			placeholderTables,
+			dataSource,
+			table,
+			signal: opts.signal
+		});
+		return {
+			rows: result.rows,
+			sql: result.sql,
+			objectKeys: uniqueKeys
+		};
+	}
+	async function query(ctx, state) {
+		const plan = buildLogicalPlan(state, { regex: true });
+		const table = ctx.table ?? plan.dataset;
+		const resolved = compileLogicalQueryPlan(plan, table);
+		return runSQL({
+			ctx: {
+				userId: ctx.userId,
+				siteId: ctx.siteId
+			},
+			table,
+			fileSets: { FILES: {
+				table,
+				partitions: resolved.partitions
+			} },
+			sql: resolved.sql,
+			params: resolved.params,
+			signal: ctx.signal
+		});
+	}
+	async function queryComparison(ctx, current, previous, filter) {
+		const adapter = createParquetResolverAdapter();
+		const currentPlan = buildLogicalPlan(current, adapter.capabilities);
+		const previousPlan = buildLogicalPlan(previous, adapter.capabilities);
+		if (currentPlan.dataset !== previousPlan.dataset) throw new Error(`queryComparison: current (${currentPlan.dataset}) and previous (${previousPlan.dataset}) must resolve to the same table`);
+		const table = ctx.table ?? currentPlan.dataset;
+		const comparison = resolveComparisonSQL(current, previous, {
+			adapter,
+			siteId: void 0
+		}, filter);
+		const totals = buildTotalsSql(current, {
+			adapter,
+			siteId: void 0
+		});
+		const fileSets = { FILES: {
+			table,
+			partitions: enumeratePartitions(currentPlan.dateRange.startDate < previousPlan.dateRange.startDate ? currentPlan.dateRange.startDate : previousPlan.dateRange.startDate, currentPlan.dateRange.endDate > previousPlan.dateRange.endDate ? currentPlan.dateRange.endDate : previousPlan.dateRange.endDate)
+		} };
+		const baseCtx = {
+			userId: ctx.userId,
+			siteId: ctx.siteId
+		};
+		const [main, count, totalsRow] = await Promise.all([
+			runSQL({
+				ctx: baseCtx,
+				table,
+				fileSets,
+				sql: comparison.sql,
+				params: comparison.params,
+				signal: ctx.signal
+			}),
+			runSQL({
+				ctx: baseCtx,
+				table,
+				fileSets,
+				sql: comparison.countSql,
+				params: comparison.countParams,
+				signal: ctx.signal
+			}),
+			runSQL({
+				ctx: baseCtx,
+				table,
+				fileSets,
+				sql: totals.sql,
+				params: totals.params,
+				signal: ctx.signal
+			})
+		]);
+		return {
+			rows: main.rows,
+			totalCount: Number(count.rows[0]?.total ?? 0),
+			totals: totalsRow.rows[0] ?? {}
+		};
+	}
+	async function queryOptimized(ctx, state) {
+		const adapter = createParquetResolverAdapter();
+		const plan = buildLogicalPlan(state, adapter.capabilities);
+		const table = ctx.table ?? plan.dataset;
+		const partitions = enumeratePartitions(plan.dateRange.startDate, plan.dateRange.endDate);
+		const { sql, params } = resolveToSQLOptimized(state, {
+			adapter,
+			siteId: void 0
+		});
+		const result = await runSQL({
+			ctx: {
+				userId: ctx.userId,
+				siteId: ctx.siteId
+			},
+			table,
+			fileSets: { FILES: {
+				table,
+				partitions
+			} },
+			sql,
+			params,
+			signal: ctx.signal
+		});
+		const firstRow = result.rows[0];
+		const totalCount = Number(firstRow?.totalCount ?? 0);
+		const totals = {
+			clicks: Number(firstRow?.totalClicks ?? 0),
+			impressions: Number(firstRow?.totalImpressions ?? 0),
+			ctr: Number(firstRow?.totalCtr ?? 0),
+			position: Number(firstRow?.totalPosition ?? 0)
+		};
+		return {
+			rows: result.rows.map((r) => {
+				const { totalCount: _tc, totalClicks: _tcl, totalImpressions: _ti, totalCtr: _tr, totalPosition: _tp, ...rest } = r;
+				return rest;
+			}),
+			totalCount,
+			totals
+		};
+	}
+	async function queryExtras(ctx, state) {
+		const adapter = createParquetResolverAdapter();
+		const extras = buildExtrasQueries(state, {
+			adapter,
+			siteId: void 0
+		});
+		if (extras.length === 0) return [];
+		const plan = buildLogicalPlan(state, adapter.capabilities);
+		const table = ctx.table ?? plan.dataset;
+		const fileSets = { FILES: {
+			table,
+			partitions: enumeratePartitions(plan.dateRange.startDate, plan.dateRange.endDate)
+		} };
+		const baseCtx = {
+			userId: ctx.userId,
+			siteId: ctx.siteId
+		};
+		const results = await Promise.all(extras.map((e) => runSQL({
+			ctx: baseCtx,
+			table,
+			fileSets,
+			sql: e.sql,
+			params: e.params,
+			signal: ctx.signal
+		})));
+		return extras.map((e, i) => ({
+			key: e.key,
+			rows: results[i].rows
+		}));
+	}
+	async function compactTiered(ctx, thresholds) {
+		return compactTieredImpl({
+			dataSource,
+			manifestStore,
+			codec
+		}, ctx, (ctx.now ?? defaultNow)(), thresholds);
+	}
+	async function gcOrphans(ctx, graceMs) {
+		return gcOrphansImpl({
+			dataSource,
+			manifestStore
+		}, (ctx.now ?? defaultNow)(), graceMs, {
+			userId: ctx.userId,
+			siteId: ctx.siteId
+		});
+	}
+	async function purgeTenant(ctx) {
+		const prefix = tenantPrefix(ctx);
+		const keys = [];
+		const keyStream = dataSource.streamList ? dataSource.streamList(prefix) : async function* () {
+			for (const k of await dataSource.list(prefix)) yield k;
+		}();
+		for await (const key of keyStream) keys.push(key);
+		if (keys.length > 0) await dataSource.delete(keys);
+		const manifestResult = await manifestStore.purgeTenant({
+			userId: ctx.userId,
+			siteId: ctx.siteId
+		});
+		return {
+			userId: ctx.userId,
+			siteId: ctx.siteId,
+			prefix,
+			objectsDeleted: keys.length,
+			entriesRemoved: manifestResult.entriesRemoved,
+			watermarksRemoved: manifestResult.watermarksRemoved,
+			syncStatesRemoved: manifestResult.syncStatesRemoved,
+			at: defaultNow()
+		};
+	}
+	async function purgeUrls(ctx, urls) {
+		const now = defaultNow();
+		const urlSet = new Set(urls);
+		let entriesRewritten = 0;
+		let rowsRemoved = 0;
+		let bytesAfter = 0;
+		if (urlSet.size === 0) return {
+			userId: ctx.userId,
+			siteId: ctx.siteId,
+			urlsRequested: 0,
+			entriesRewritten: 0,
+			rowsRemoved: 0,
+			bytesAfter: 0,
+			at: now
+		};
+		for (const table of URL_PURGE_TABLES) {
+			const entries = await manifestStore.listLive({
+				userId: ctx.userId,
+				siteId: ctx.siteId,
+				table
+			});
+			for (const entry of entries) await manifestStore.withLock({
+				userId: entry.userId,
+				siteId: entry.siteId,
+				table,
+				partition: entry.partition
+			}, async () => {
+				const rows = await codec.readRows({ table }, entry.objectKey, dataSource);
+				const kept = rows.filter((r) => typeof r.url !== "string" || !urlSet.has(r.url));
+				const removed = rows.length - kept.length;
+				if (removed === 0) return;
+				const searchType = entry.searchType;
+				const newKey = objectKey({
+					userId: entry.userId,
+					siteId: entry.siteId
+				}, table, entry.partition, now, searchType);
+				const { bytes, rowCount } = await codec.writeRows({ table }, kept, newKey, dataSource);
+				const newEntry = {
+					userId: entry.userId,
+					siteId: entry.siteId,
+					table,
+					partition: entry.partition,
+					objectKey: newKey,
+					rowCount,
+					bytes,
+					createdAt: now,
+					schemaVersion: entry.schemaVersion ?? currentSchemaVersion(table),
+					...entry.tier !== void 0 ? { tier: entry.tier } : {},
+					...searchType !== void 0 ? { searchType } : {}
+				};
+				await manifestStore.registerVersion(newEntry, [entry]);
+				entriesRewritten++;
+				rowsRemoved += removed;
+				bytesAfter += bytes;
+			});
+		}
+		return {
+			userId: ctx.userId,
+			siteId: ctx.siteId,
+			urlsRequested: urlSet.size,
+			entriesRewritten,
+			rowsRemoved,
+			bytesAfter,
+			at: now
+		};
+	}
+	return {
+		writeDay,
+		query,
+		queryComparison,
+		queryExtras,
+		queryOptimized,
+		runSQL,
+		compactTiered,
+		gcOrphans,
+		purgeTenant,
+		purgeUrls,
+		listLive: (filter) => manifestStore.listLive(filter),
+		listAll: (filter) => manifestStore.listAll(filter),
+		getWatermarks: (filter) => manifestStore.getWatermarks(filter),
+		getSyncStates: (filter) => manifestStore.getSyncStates(filter),
+		setSyncState: (scope, state, detail) => manifestStore.setSyncState(scope, state, detail),
+		readObject: (key) => dataSource.read(key)
+	};
+}
+export { createDuckDBExecutor as a, createDuckDBCodec as i, createStorageEngine as n, canonicalEmptyParquetSchema as r, MAX_DAY_BYTES as t };