@gscdump/cloudflare 1.4.0 → 1.4.1

package/dist/server-tail/index.mjs

@@ -1,661 +1,5 @@
-import { bindLiterals } from "@gscdump/engine/sql";
-import { ARCHETYPE_EXECUTION_CLASS } from "@gscdump/contracts/archetypes";
-import { err, ok, unwrapResult } from "gscdump/result";
-import { SEARCH_TYPE_INT } from "@gscdump/engine/iceberg";
-const TABLE_PLACEHOLDER = "{{TABLE}}";
-const FACT_ALIAS = "fact";
-function factTableRef() {
-	return `${TABLE_PLACEHOLDER} AS ${FACT_ALIAS}`;
-}
-function dimColumn(dim) {
-	if (dim === "page") return "url";
-	if (dim === "queryCanonical") return `COALESCE((SELECT qd.query_canonical FROM query_dim qd WHERE qd.query = ${FACT_ALIAS}.query LIMIT 1), ${FACT_ALIAS}.query)`;
-	return dim;
-}
-function dimSelect(dim) {
-	const col = dimColumn(dim);
-	return dim === "queryCanonical" ? `${col} AS queryCanonical` : col;
-}
-function tableForDimensions(dims) {
-	const set = new Set(dims.filter((d) => d !== "date"));
-	if (set.has("page") && (set.has("query") || set.has("queryCanonical"))) return "page_queries";
-	if (set.has("query") || set.has("queryCanonical")) return "queries";
-	if (set.has("country")) return "countries";
-	if (set.has("device")) return "dates";
-	return "pages";
-}
-function tableForTopNBreakdown(q) {
-	const dims = [q.dimension];
-	for (const facet of q.facets ?? []) {
-		const hasPage = q.dimension === "page" || facet.column === "page";
-		const hasQuery = q.dimension === "query" || q.dimension === "queryCanonical" || facet.column === "query" || facet.column === "queryCanonical";
-		if (hasPage && hasQuery) dims.push(facet.column);
-	}
-	return tableForDimensions(dims);
-}
-function metricExpr(metric) {
-	switch (metric) {
-		case "clicks": return "SUM(clicks) AS clicks";
-		case "impressions": return "SUM(impressions) AS impressions";
-		case "ctr": return "SUM(clicks) / NULLIF(SUM(impressions), 0) AS ctr";
-		case "position": return "SUM(sum_position) / NULLIF(SUM(impressions), 0) + 1 AS position";
-		default: throw new Error(`[archetype-sql] unknown metric: ${JSON.stringify(metric)}`);
-	}
-}
-function metricAlias(metric) {
-	switch (metric) {
-		case "clicks":
-		case "impressions":
-		case "ctr":
-		case "position": return metric;
-		default: throw new Error(`[archetype-sql] unknown order metric: ${JSON.stringify(metric)}`);
-	}
-}
-const DEVICE_SUFFIXES = [
-	"desktop",
-	"mobile",
-	"tablet"
-];
-function metricExprForSource(metric, source) {
-	switch (metric) {
-		case "clicks": return `SUM(${source.clicks}) AS clicks`;
-		case "impressions": return `SUM(${source.impressions}) AS impressions`;
-		case "ctr": return `SUM(${source.clicks}) / NULLIF(SUM(${source.impressions}), 0) AS ctr`;
-		case "position": return `SUM(${source.sumPosition}) / NULLIF(SUM(${source.impressions}), 0) + 1 AS position`;
-		default: throw new Error(`[archetype-sql] unknown metric: ${JSON.stringify(metric)}`);
-	}
-}
-function deviceSource(suffix) {
-	return {
-		clicks: `clicks_${suffix}`,
-		impressions: `impressions_${suffix}`,
-		sumPosition: `sum_position_${suffix}`
-	};
-}
-const STD_METRICS = [
-	"clicks",
-	"impressions",
-	"ctr",
-	"position"
-];
-function coalesceMetric(metric, src, alias) {
-	const ref = `${src}.${metric}`;
-	return metric === "clicks" || metric === "impressions" ? `CAST(COALESCE(${ref}, 0) AS DOUBLE) AS ${alias}` : `COALESCE(${ref}, 0) AS ${alias}`;
-}
-function prevAlias(metric) {
-	return `prev${metric.charAt(0).toUpperCase()}${metric.slice(1)}`;
-}
-function moverClause(movers) {
-	const curClicks = "COALESCE(c.clicks, 0)";
-	const prevClicks = "COALESCE(p.clicks, 0)";
-	const curImpr = "COALESCE(c.impressions, 0)";
-	const prevImpr = "COALESCE(p.impressions, 0)";
-	switch (movers) {
-		case "improving": return { where: `${curClicks} > ${prevClicks}` };
-		case "declining": return { where: `${curClicks} < ${prevClicks}` };
-		case "new": return { where: `${prevImpr} = 0 AND ${curImpr} > 0` };
-		case "lost": return { where: `${curImpr} = 0 AND ${prevImpr} > 0` };
-		default: throw new Error(`[archetype-sql] unknown movers mode: ${movers}`);
-	}
-}
-function moverOrderByAlias(movers) {
-	switch (movers) {
-		case "improving": return "(clicks - prevClicks) DESC";
-		case "declining": return "(clicks - prevClicks) ASC";
-		case "new": return "clicks DESC, impressions DESC";
-		case "lost": return "prevImpressions DESC";
-		default: throw new Error(`[archetype-sql] unknown movers mode: ${movers}`);
-	}
-}
-function sqlStringLiteral(value) {
-	return `'${value.replace(/'/g, "''")}'`;
-}
-function partitionWhere(q, partitionPruned = false, mode = "bare") {
-	if (partitionPruned) return {
-		clause: "date BETWEEN ? AND ?",
-		params: [q.range.start, q.range.end]
-	};
-	return {
-		clause: `${mode === "r2-sql-concat" ? "CONCAT(site_id, '')" : "site_id"} = ? AND ${mode === "r2-sql-concat" ? "CONCAT(search_type, '')" : "search_type"} = ? AND date BETWEEN ? AND ?`,
-		params: [
-			q.siteId,
-			q.searchType,
-			q.range.start,
-			q.range.end
-		]
-	};
-}
-function facetPredicate(query) {
-	const facets = query.facets;
-	if (!facets?.length) return {
-		sql: "",
-		params: []
-	};
-	const parts = [];
-	const params = [];
-	for (const f of facets) {
-		const col = dimColumn(f.column);
-		switch (f.op) {
-			case "eq":
-				parts.push(`${col} = ?`);
-				params.push(f.value);
-				break;
-			case "regex":
-				parts.push(`regexp_matches(LOWER(${col}), ?)`);
-				params.push(f.value);
-				break;
-			case "notRegex":
-				parts.push(`NOT regexp_matches(LOWER(${col}), ?)`);
-				params.push(f.value);
-				break;
-			default: throw new Error(`[archetype-sql] unknown facet op: ${f.op}`);
-		}
-	}
-	return {
-		sql: parts.length ? ` AND ${parts.join(" AND ")}` : "",
-		params
-	};
-}
-function buildSiteDailyTimeseries(q, pruned, mode) {
-	const w = partitionWhere(q, pruned, mode);
-	const metrics = q.metrics.map(metricExpr).join(", ");
-	return {
-		table: "dates",
-		params: w.params,
-		sql: `SELECT date, ${metrics} FROM ${factTableRef()} WHERE ${w.clause} GROUP BY date ORDER BY date ASC`
-	};
-}
-function buildEntityDailyTimeseries(q, pruned, mode) {
-	const table = tableForDimensions([q.entity.dimension]);
-	const w = partitionWhere(q, pruned, mode);
-	const col = dimColumn(q.entity.dimension);
-	const metrics = q.metrics.map(metricExpr).join(", ");
-	return {
-		table,
-		params: [...w.params, q.entity.value],
-		sql: `SELECT date, ${metrics} FROM ${factTableRef()} WHERE ${w.clause} AND ${col} = ? GROUP BY date ORDER BY date ASC`
-	};
-}
-function buildEntityDailySparkline(q, pruned, mode) {
-	const table = tableForDimensions([q.dimension]);
-	const w = partitionWhere(q, pruned, mode);
-	const col = dimColumn(q.dimension);
-	if (q.entities.length === 0) throw new Error("entity-daily-sparkline: empty entities - resolver must pre-resolve the top-N list");
-	const inList = q.entities.map(sqlStringLiteral).join(", ");
-	return {
-		table,
-		params: w.params,
-		sql: `SELECT date, ${col} AS entity, ${metricExpr(q.metric)} FROM ${factTableRef()} WHERE ${w.clause} AND ${col} IN (${inList}) GROUP BY date, ${col} ORDER BY date ASC`
-	};
-}
-function buildTopNBreakdown(q, pruned, mode) {
-	const table = tableForTopNBreakdown(q);
-	const w = partitionWhere(q, pruned, mode);
-	if (!q.orderBy || !q.orderBy.metric || !q.orderBy.dir) throw new Error(`[archetype-sql] top-n-breakdown requires orderBy.{metric,dir}, got: ${JSON.stringify(q.orderBy)}`);
-	const order = `${metricAlias(q.orderBy.metric)} ${q.orderBy.dir.toUpperCase()}`;
-	const limit = `LIMIT ${Math.max(0, Math.floor(q.limit))}`;
-	const offset = q.offset && q.offset > 0 ? ` OFFSET ${Math.floor(q.offset)}` : "";
-	const metricList0 = q.metrics.includes(q.orderBy.metric) ? q.metrics : [...q.metrics, q.orderBy.metric];
-	const metricList = q.compareRange && q.movers ? [.../* @__PURE__ */ new Set([
-		...metricList0,
-		"clicks",
-		"impressions"
-	])] : metricList0;
-	const variantSel = q.dimension === "queryCanonical" ? ", COUNT(DISTINCT query) AS variantCount" : "";
-	if (q.dimension === "device") {
-		if (q.compareRange) {
-			const wPrev = partitionWhere({
-				...q,
-				range: q.compareRange
-			}, pruned, mode);
-			const deviceSelects = (clause, ml) => DEVICE_SUFFIXES.map((suffix) => {
-				const source = deviceSource(suffix);
-				const metrics = ml.map((m) => metricExprForSource(m, source)).join(", ");
-				return `SELECT '${suffix.toUpperCase()}' AS device, ${metrics} FROM ${factTableRef()} WHERE ${clause}`;
-			}).join(" UNION ALL ");
-			const inner = `SELECT COALESCE(c.device, p.device) AS device, ${metricList.map((m) => coalesceMetric(m, "c", m)).join(", ")}, ${STD_METRICS.map((m) => coalesceMetric(m, "p", prevAlias(m))).join(", ")} FROM cur c FULL OUTER JOIN prev p ON c.device = p.device`;
-			const sql = `WITH cur AS (${deviceSelects(w.clause, metricList)}), prev AS (${deviceSelects(wPrev.clause, STD_METRICS)}) SELECT * FROM (${inner}) t ORDER BY ${order} ${limit}${offset}`;
-			return {
-				table,
-				params: [...DEVICE_SUFFIXES.flatMap(() => w.params), ...DEVICE_SUFFIXES.flatMap(() => wPrev.params)],
-				sql
-			};
-		}
-		const sql = `${DEVICE_SUFFIXES.map((suffix) => {
-			const source = deviceSource(suffix);
-			const metrics = metricList.map((m) => metricExprForSource(m, source)).join(", ");
-			return `SELECT '${suffix.toUpperCase()}' AS device, ${metrics} FROM ${factTableRef()} WHERE ${w.clause}`;
-		}).join(" UNION ALL ")} ORDER BY ${order} ${limit}${offset}`;
-		return {
-			table,
-			params: DEVICE_SUFFIXES.flatMap(() => w.params),
-			sql
-		};
-	}
-	const col = dimColumn(q.dimension);
-	const facet = facetPredicate(q);
-	const totalCol = q.includeTotal ? ", COUNT(*) OVER() AS __total" : "";
-	if (q.compareRange) {
-		const wPrev = partitionWhere({
-			...q,
-			range: q.compareRange
-		}, pruned, mode);
-		const curMetrics = metricList.map(metricExpr).join(", ");
-		const prevMetrics = STD_METRICS.map((m) => metricExpr(m)).join(", ");
-		const curCols = metricList.map((m) => coalesceMetric(m, "c", m)).join(", ");
-		const prevCols = STD_METRICS.map((m) => coalesceMetric(m, "p", prevAlias(m))).join(", ");
-		const variantOut = q.dimension === "queryCanonical" ? ", c.variantCount AS variantCount" : "";
-		const moverWhere = q.movers ? `WHERE ${moverClause(q.movers).where} ` : "";
-		const outerOrder = q.movers ? moverOrderByAlias(q.movers) : order;
-		const inner = `SELECT COALESCE(c.k, p.k) AS ${q.dimension}, ${curCols}, ${prevCols}${variantOut}${totalCol} FROM cur c FULL OUTER JOIN prev p ON c.k = p.k ${moverWhere}`;
-		const sql = `WITH cur AS (SELECT ${col} AS k, ${curMetrics}${variantSel} FROM ${factTableRef()} WHERE ${w.clause}${facet.sql} GROUP BY ${col}), prev AS (SELECT ${col} AS k, ${prevMetrics} FROM ${factTableRef()} WHERE ${wPrev.clause}${facet.sql} GROUP BY ${col}) SELECT * FROM (${inner}) t ORDER BY ${outerOrder} ${limit}${offset}`;
-		return {
-			table,
-			params: [
-				...w.params,
-				...facet.params,
-				...wPrev.params,
-				...facet.params
-			],
-			sql
-		};
-	}
-	const metrics = metricList.map(metricExpr).join(", ");
-	const sql = `SELECT ${dimSelect(q.dimension)}, ${metrics}${variantSel}${totalCol} FROM ${factTableRef()} WHERE ${w.clause}${facet.sql} GROUP BY ${col} ORDER BY ${order} ${limit}${offset}`;
-	return {
-		table,
-		params: [...w.params, ...facet.params],
-		sql
-	};
-}
-function buildSingleRowLookup(q, pruned, mode) {
-	const dims = Object.keys(q.match);
-	const table = tableForDimensions(dims);
-	const w = partitionWhere(q, pruned, mode);
-	const params = [...w.params];
-	let clause = w.clause;
-	for (const dim of dims) {
-		clause += ` AND ${dimColumn(dim)} = ?`;
-		params.push(q.match[dim]);
-	}
-	const metrics = q.metrics.map(metricExpr).join(", ");
-	const groupBy = dims.length > 0 ? ` GROUP BY ${dims.map(dimColumn).join(", ")}` : "";
-	return {
-		table,
-		params,
-		sql: `SELECT ${dims.length > 0 ? `${dims.map(dimSelect).join(", ")}, ${metrics}` : metrics} FROM ${factTableRef()} WHERE ${clause}${groupBy}`
-	};
-}
-function buildMultiSeriesStackedDaily(q, pruned, mode) {
-	const table = tableForDimensions([q.seriesDimension]);
-	const w = partitionWhere(q, pruned, mode);
-	if (q.seriesDimension === "device") {
-		const selects = DEVICE_SUFFIXES.map((suffix) => {
-			const source = deviceSource(suffix);
-			return `SELECT date, '${suffix.toUpperCase()}' AS device, ${metricExprForSource(q.metric, source)} FROM ${factTableRef()} WHERE ${w.clause} GROUP BY date`;
-		});
-		return {
-			table,
-			params: DEVICE_SUFFIXES.flatMap(() => w.params),
-			sql: `${selects.join(" UNION ALL ")} ORDER BY date ASC, device ASC`
-		};
-	}
-	const col = dimColumn(q.seriesDimension);
-	return {
-		table,
-		params: w.params,
-		sql: `SELECT date, ${dimSelect(q.seriesDimension)}, ${metricExpr(q.metric)} FROM ${factTableRef()} WHERE ${w.clause} GROUP BY date, ${col} ORDER BY date ASC`
-	};
-}
-function buildTwoDimensionDetail(q, pruned, mode) {
-	const w = partitionWhere(q, pruned, mode);
-	const params = [...w.params];
-	let clause = w.clause;
-	if (q.filter?.page) {
-		clause += ` AND url = ?`;
-		params.push(q.filter.page);
-	}
-	if (q.filter?.query) {
-		clause += ` AND query = ?`;
-		params.push(q.filter.query);
-	}
-	const facet = facetPredicate(q);
-	clause += facet.sql;
-	params.push(...facet.params);
-	let sql = `SELECT url, query, ${(q.orderBy && !q.metrics.includes(q.orderBy.metric) ? [...q.metrics, q.orderBy.metric] : q.metrics).map(metricExpr).join(", ")} FROM ${factTableRef()} WHERE ${clause} GROUP BY url, query`;
-	if (q.orderBy) sql += ` ORDER BY ${metricAlias(q.orderBy.metric)} ${q.orderBy.dir.toUpperCase()}`;
-	if (q.limit && q.limit > 0) sql += ` LIMIT ${Math.floor(q.limit)}`;
-	return {
-		table: "page_queries",
-		params,
-		sql
-	};
-}
-function buildArchetypeSql(query, opts = {}) {
-	const pruned = opts.partitionPruned ?? false;
-	const mode = opts.partitionPredicateMode ?? (opts.partitionKeyEncoding === "string" ? "r2-sql-concat" : "bare");
-	switch (query.archetype) {
-		case "site-daily-timeseries": return buildSiteDailyTimeseries(query, pruned, mode);
-		case "entity-daily-timeseries": return buildEntityDailyTimeseries(query, pruned, mode);
-		case "entity-daily-sparkline": return buildEntityDailySparkline(query, pruned, mode);
-		case "top-n-breakdown": return buildTopNBreakdown(query, pruned, mode);
-		case "single-row-lookup": return buildSingleRowLookup(query, pruned, mode);
-		case "multi-series-stacked-daily": return buildMultiSeriesStackedDaily(query, pruned, mode);
-		case "two-dimension-detail": return buildTwoDimensionDetail(query, pruned, mode);
-		case "arbitrary-sql": throw new Error("buildArchetypeSql: arbitrary-sql carries caller SQL - the DuckDB executor runs it verbatim");
-		case "aux-cloud-only": throw new Error("buildArchetypeSql: aux-cloud-only is not an Iceberg query");
-	}
-}
-var ServerTailRoutingError = class extends Error {
-	name = "ServerTailRoutingError";
-};
-function routingErrorToException(error) {
-	return error;
-}
-function hasRegexFacet(query) {
-	return query.facets?.some((f) => f.op === "regex" || f.op === "notRegex") ?? false;
-}
-function referencesQueryDim(query) {
-	const q = query;
-	if (q.dimension === "queryCanonical" || q.seriesDimension === "queryCanonical") return true;
-	if (q.entity?.dimension === "queryCanonical") return true;
-	if (q.match && "queryCanonical" in q.match) return true;
-	return q.facets?.some((f) => f.column === "queryCanonical") ?? false;
-}
-function resolveServerTailEngineResult(query) {
-	const cls = ARCHETYPE_EXECUTION_CLASS[query.archetype];
-	if (cls === "cloud-only") return err(new ServerTailRoutingError(`archetype '${query.archetype}' is cloud-only — not a server-tail query`));
-	if (cls === "duckdb") return ok("duckdb");
-	if (query.archetype === "top-n-breakdown" && query.offset && query.offset > 0) return ok("duckdb");
-	if (referencesQueryDim(query)) return ok("duckdb");
-	if (hasRegexFacet(query)) return ok("duckdb");
-	return ok("r2-sql");
-}
-function resolveServerTailEngine(query) {
-	return unwrapResult(resolveServerTailEngineResult(query), routingErrorToException);
-}
-function sourceFor(engine) {
-	return engine === "r2-sql" ? "server-r2-sql" : "server-duckdb";
-}
-function extractTotal(rows) {
-	if (!rows.length || !("__total" in rows[0])) return { rows };
-	const totalRows = Number(rows[0].__total) || 0;
-	return {
-		rows: rows.map((r) => {
-			const { __total, ...rest } = r;
-			return rest;
-		}),
-		totalRows
-	};
-}
-function createServerTailDispatcher(config) {
-	function route(query) {
-		return resolveServerTailEngine(query);
-	}
-	async function execute(query, directive) {
-		const engine = route(query);
-		if (directive && directive.engine !== engine && engine === "r2-sql") return runOn("duckdb", query);
-		return runOn(engine, query);
-	}
-	async function runOn(engine, query) {
-		if (engine === "r2-sql") {
-			const res = await config.r2Sql.runArchetype(query);
-			const { rows, totalRows } = extractTotal(res.rows);
-			return {
-				archetype: query.archetype,
-				rows,
-				source: sourceFor("r2-sql"),
-				meta: {
-					rowCount: rows.length,
-					queryMs: res.queryMs,
-					...totalRows !== void 0 ? { totalRows } : {}
-				}
-			};
-		}
-		const res = await config.duckdb.runArchetype(query);
-		const { rows, totalRows } = extractTotal(res.rows);
-		return {
-			archetype: query.archetype,
-			rows,
-			source: sourceFor("duckdb"),
-			meta: {
-				rowCount: rows.length,
-				queryMs: res.queryMs,
-				...totalRows !== void 0 ? { totalRows } : {}
-			}
-		};
-	}
-	return {
-		route,
-		execute
-	};
-}
-var DuckDbIcebergError = class extends Error {
-	name = "DuckDbIcebergError";
-};
-var DuckDbIcebergTimeoutError = class extends Error {
-	name = "DuckDbIcebergTimeoutError";
-	constructor(timeoutMs) {
-		super(`DuckDB-over-Iceberg query exceeded ${timeoutMs}ms deadline`);
-	}
-};
-function duckDbIcebergErrorToException(error) {
-	return error;
-}
-const DEFAULT_TIMEOUT_MS$1 = 25e3;
-function icebergTableRef(config, table) {
-	if (config.tableRefStyle === "catalog") return `${config.namespace}.${table}`;
-	return `iceberg_scan('${config.warehouse}/${config.namespace}/${table}')`;
-}
-function withDeadline(op, timeoutMs) {
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => reject(new DuckDbIcebergTimeoutError(timeoutMs)), timeoutMs);
-		op.then(resolve, reject).finally(() => clearTimeout(timer));
-	});
-}
-function resolveTablePlaceholders(sql, config) {
-	return sql.replace(/\{\{(\w+)\}\}/g, (_, table) => icebergTableRef(config, table));
-}
-function createDuckDbIcebergExecutor(config) {
-	const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
-	async function sendResult(sql) {
-		const started = Date.now();
-		const deadlineAt = Date.now() + timeoutMs;
-		const raced = await withDeadline(config.svc.runSQL({
-			sql,
-			deadlineAt
-		}), timeoutMs).then((value) => ok(value)).catch((error) => error instanceof DuckDbIcebergTimeoutError ? err(error) : err(new DuckDbIcebergError(`DUCKDB_SVC.runSQL failed: ${error.message}`)));
-		if (!raced.ok) return raced;
-		const result = raced.value;
-		return ok({
-			rows: result.rows ?? [],
-			sql: result.sql ?? sql,
-			queryMs: Date.now() - started
-		});
-	}
-	async function send(sql) {
-		return unwrapResult(await sendResult(sql), duckDbIcebergErrorToException);
-	}
-	function runSqlResult(sql, params = []) {
-		return sendResult(bindLiterals(resolveTablePlaceholders(sql, config), params));
-	}
-	function runSql(sql, params = []) {
-		return send(bindLiterals(resolveTablePlaceholders(sql, config), params));
-	}
-	function runPlan(plan) {
-		return send(bindLiterals(plan.sql.split(TABLE_PLACEHOLDER).join(icebergTableRef(config, plan.table)), plan.params));
-	}
-	function runPlanResult(plan) {
-		return sendResult(bindLiterals(plan.sql.split(TABLE_PLACEHOLDER).join(icebergTableRef(config, plan.table)), plan.params));
-	}
-	function runArchetypeResult(query) {
-		if (query.archetype === "arbitrary-sql") return runSqlResult(query.sql, query.params ?? []);
-		if (query.archetype === "aux-cloud-only") return Promise.resolve(err(new DuckDbIcebergError("aux-cloud-only is not an Iceberg query")));
-		return runPlanResult(buildArchetypeSql(query));
-	}
-	async function runArchetype(query) {
-		return unwrapResult(await runArchetypeResult(query), duckDbIcebergErrorToException);
-	}
-	return {
-		runSql,
-		runPlan,
-		runArchetype,
-		runArchetypeResult
-	};
-}
-function r2TableRef(namespace, table) {
-	return `${namespace}.${table}`;
-}
-var R2SqlError = class extends Error {
-	status;
-	name = "R2SqlError";
-	constructor(message, status) {
-		super(message);
-		this.status = status;
-	}
-};
-var R2SqlTimeoutError = class extends Error {
-	name = "R2SqlTimeoutError";
-	constructor(timeoutMs) {
-		super(`R2 SQL query exceeded ${timeoutMs}ms deadline`);
-	}
-};
-function r2SqlErrorToException(error) {
-	return error;
-}
-const DEFAULT_API_BASE = "https://api.sql.cloudflarestorage.com/api/v1";
-const DEFAULT_TIMEOUT_MS = 25e3;
-const PARTITION_PREDICATE_RE = /\b(site_id|search_type)(\s*=)/g;
-function workaroundPartitionEquality(sql) {
-	return sql.replace(PARTITION_PREDICATE_RE, (_m, col, eq) => `CONCAT(${col}, '')${eq}`);
-}
-function escapeSqlValue(value) {
-	if (value === null || value === void 0) return "NULL";
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new R2SqlError(`cannot embed non-finite number in SQL: ${value}`);
-		return String(value);
-	}
-	if (typeof value === "bigint") return value.toString();
-	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-	return `'${String(value).replace(/'/g, "''")}'`;
-}
-function inlineParams(sql, params) {
-	let out = "";
-	let paramIndex = 0;
-	let inString = false;
-	for (let i = 0; i < sql.length; i++) {
-		const ch = sql[i];
-		if (ch === "'") {
-			if (inString && sql[i + 1] === "'") {
-				out += "''";
-				i++;
-				continue;
-			}
-			inString = !inString;
-			out += ch;
-			continue;
-		}
-		if (ch === "?" && !inString) {
-			if (paramIndex >= params.length) throw new R2SqlError(`SQL has more ? placeholders than params (${params.length})`);
-			out += escapeSqlValue(params[paramIndex++]);
-			continue;
-		}
-		out += ch;
-	}
-	if (paramIndex !== params.length) throw new R2SqlError(`SQL has ${paramIndex} ? placeholders but ${params.length} params supplied`);
-	return out;
-}
-function normalizeRows(result) {
-	if (!result) return [];
-	if (Array.isArray(result.rows)) return result.rows;
-	if (Array.isArray(result.columns) && Array.isArray(result.data)) {
-		const cols = result.columns;
-		return result.data.map((tuple) => {
-			const row = {};
-			cols.forEach((col, idx) => {
-				row[col] = tuple[idx] ?? null;
-			});
-			return row;
-		});
-	}
-	return [];
-}
-function coerceIntSiteId(siteId, mapper) {
-	const mapped = mapper ? mapper(siteId) : siteId;
-	const n = Number(mapped);
-	if (!Number.isSafeInteger(n)) throw new R2SqlError("int R2 SQL catalog requires a numeric site_id partition value; pass partitionSiteId for public ids");
-	return n;
-}
-function withEncodedPartitions(query, encoding, siteIdMapper) {
-	if (encoding === "string") return query;
-	const scoped = query;
-	const searchType = SEARCH_TYPE_INT[scoped.searchType];
-	if (searchType === void 0) throw new R2SqlError(`unknown search_type for int R2 SQL catalog: ${String(scoped.searchType)}`);
-	return {
-		...query,
-		siteId: coerceIntSiteId(scoped.siteId, siteIdMapper),
-		searchType
-	};
-}
-function createR2SqlClient(config) {
-	const fetchImpl = config.fetchImpl ?? globalThis.fetch;
-	const apiBase = config.apiBase ?? DEFAULT_API_BASE;
-	const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	const partitionKeyEncoding = config.partitionKeyEncoding ?? "int";
-	const endpoint = `${apiBase}/accounts/${config.accountId}/r2-sql/query/${config.bucket}`;
-	async function queryResult(sql) {
-		const started = Date.now();
-		const controller = new AbortController();
-		const timer = setTimeout(() => controller.abort(new R2SqlTimeoutError(timeoutMs)), timeoutMs);
-		let response;
-		try {
-			response = await fetchImpl(endpoint, {
-				method: "POST",
-				headers: {
-					"authorization": `Bearer ${config.token}`,
-					"content-type": "application/json",
-					"user-agent": "gscdump-cloudflare-r2sql/1.0"
-				},
-				body: JSON.stringify({ query: sql }),
-				signal: controller.signal
-			});
-		} catch (error) {
-			if (error instanceof R2SqlTimeoutError || error?.name === "AbortError") return err(new R2SqlTimeoutError(timeoutMs));
-			return err(new R2SqlError(`R2 SQL request failed: ${error.message}`));
-		} finally {
-			clearTimeout(timer);
-		}
-		if (!response.ok) {
-			const text = await response.text().catch(() => "");
-			return err(new R2SqlError(`R2 SQL HTTP ${response.status}: ${text}`, response.status));
-		}
-		const envelope = await response.json();
-		if (!envelope.success) return err(new R2SqlError(`R2 SQL query rejected: ${envelope.errors?.map((e) => e.message).join("; ") ?? "unknown R2 SQL error"}`));
-		return ok({
-			rows: normalizeRows(envelope.result),
-			sql,
-			queryMs: Date.now() - started
-		});
-	}
-	async function query(sql) {
-		return unwrapResult(await queryResult(sql), r2SqlErrorToException);
-	}
-	function materializePlan(plan) {
-		const tableRef = r2TableRef(config.namespace, plan.table);
-		return inlineParams(plan.sql.split(TABLE_PLACEHOLDER).join(tableRef), plan.params);
-	}
-	function runPlan(plan) {
-		const sql = materializePlan(plan);
-		return query(partitionKeyEncoding === "string" ? workaroundPartitionEquality(sql) : sql);
-	}
-	function runArchetype(archetypeQuery) {
-		return query(materializePlan(buildArchetypeSql(withEncodedPartitions(archetypeQuery, partitionKeyEncoding, config.partitionSiteId), { partitionKeyEncoding })));
-	}
-	return {
-		query,
-		queryResult,
-		runPlan,
-		runArchetype
-	};
-}
+import { TABLE_PLACEHOLDER, buildArchetypeSql } from "./archetype-sql.mjs";
+import { ServerTailRoutingError, createServerTailDispatcher, resolveServerTailEngine, resolveServerTailEngineResult } from "./dispatcher.mjs";
+import { DuckDbIcebergError, DuckDbIcebergTimeoutError, createDuckDbIcebergExecutor } from "./duckdb-iceberg-executor.mjs";
+import { R2SqlError, R2SqlTimeoutError, createR2SqlClient } from "./r2-sql-client.mjs";
 export { DuckDbIcebergError, DuckDbIcebergTimeoutError, R2SqlError, R2SqlTimeoutError, ServerTailRoutingError, TABLE_PLACEHOLDER, buildArchetypeSql, createDuckDbIcebergExecutor, createR2SqlClient, createServerTailDispatcher, resolveServerTailEngine, resolveServerTailEngineResult };