@gscdump/engine-duckdb-wasm 1.4.0 → 1.4.1

package/dist/index.mjs

@@ -1,1557 +1,11 @@
-import { arrowToRows } from "@gscdump/engine/arrow";
-import { DefaultLogger, NoopLogger, entityKind } from "drizzle-orm";
-import { PgAsyncDatabase, PgAsyncPreparedQuery, PgAsyncSession, PgDialect } from "drizzle-orm/pg-core";
-import { buildRelations } from "drizzle-orm/relations";
-import { createScopedHelpers } from "@gscdump/engine/scope";
-import { countries, dates, drizzleSchema as schema, hourly_pages, page_queries, pages, queries } from "@gscdump/engine/schema";
-import { runAnalyzerFromSource } from "@gscdump/engine/analyzer";
-import { pgResolverAdapter } from "@gscdump/engine/resolver";
-import { createAttachedTableSource } from "@gscdump/engine/source";
-import { sqlEscape } from "@gscdump/engine/sql";
-import { err, ok, unwrapResult } from "gscdump/result";
+import { compileArchetypeSql, tableForArchetype } from "./archetype-sql.mjs";
+import { createClient } from "./drizzle-adapter/client.mjs";
+import { DuckDBWasmDatabase, drizzle } from "./drizzle-adapter/driver.mjs";
+import "./drizzle-adapter/index.mjs";
+import { overlayViewBody } from "./overlay-view.mjs";
+import { OpfsQuotaExceededError, attachOpfsParquetTables, clearOpfsSnapshotCache, estimateOpfsStorage, readOpfsSnapshotFile, requestPersistentStorage } from "./opfs.mjs";
+import { countries, dates, hourly_pages, page_queries, pages, queries, schema } from "./schema.mjs";
+import { createInsightRunner, mergeScope, scopeFor } from "./runner.mjs";
+import { BrowserAttachBudgetExceededError, attachParquetTables, attachParquetUrlTables, attachParquetUrlTablesResult, bootDuckDBWasm, browserAttachErrors, createBrowserAnalysisRuntime, isBrowserAttachError } from "./runtime.mjs";
 import { resolveWindow } from "@gscdump/engine/period";
-const METRIC_SQL = {
-	clicks: "SUM(clicks)",
-	impressions: "SUM(impressions)",
-	ctr: "CASE WHEN SUM(impressions) = 0 THEN 0 ELSE SUM(clicks) * 1.0 / SUM(impressions) END",
-	position: "CASE WHEN SUM(impressions) = 0 THEN NULL ELSE SUM(sum_position) * 1.0 / SUM(impressions) + 1 END"
-};
-const DIM_COLUMN = {
-	page: "url",
-	query: "query",
-	country: "country",
-	date: "date",
-	searchAppearance: "search_appearance"
-};
-function quoteIdent(value) {
-	return `"${value.replace(/"/g, "\"\"")}"`;
-}
-function qualifiedColumn(table, column) {
-	return `${quoteIdent(table)}.${quoteIdent(column)}`;
-}
-function queryCanonicalExpr(table) {
-	const queryRef = qualifiedColumn(table, "query");
-	return `COALESCE((SELECT qd.query_canonical FROM query_dim qd WHERE qd.query = ${queryRef} LIMIT 1), ${queryRef})`;
-}
-function dimExpr(dim, table) {
-	return dim === "queryCanonical" ? queryCanonicalExpr(table) : DIM_COLUMN[dim] ?? dim;
-}
-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(query) {
-	const dims = [query.dimension];
-	for (const facet of query.facets ?? []) {
-		const hasPage = query.dimension === "page" || facet.column === "page";
-		const hasQuery = query.dimension === "query" || query.dimension === "queryCanonical" || facet.column === "query" || facet.column === "queryCanonical";
-		if (hasPage && hasQuery) dims.push(facet.column);
-	}
-	return tableForDimensions(dims);
-}
-function metricExpr(metric) {
-	const expr = METRIC_SQL[metric];
-	if (!expr) throw new Error(`[archetype-sql] unknown metric: ${metric}`);
-	return expr;
-}
-function metricSelectList(metrics) {
-	return metrics.map((m) => `${metricExpr(m)} AS ${m}`).join(", ");
-}
-const DEVICE_VALUES = [
-	"DESKTOP",
-	"MOBILE",
-	"TABLET"
-];
-const DEVICE_SUFFIX = {
-	DESKTOP: "desktop",
-	MOBILE: "mobile",
-	TABLET: "tablet"
-};
-function deviceMetricExpr(metric, suffix) {
-	switch (metric) {
-		case "clicks": return `SUM(clicks_${suffix})`;
-		case "impressions": return `SUM(impressions_${suffix})`;
-		case "ctr": return `CASE WHEN SUM(impressions_${suffix}) = 0 THEN 0 ELSE SUM(clicks_${suffix}) * 1.0 / SUM(impressions_${suffix}) END`;
-		case "position": return `CASE WHEN SUM(impressions_${suffix}) = 0 THEN NULL ELSE SUM(sum_position_${suffix}) * 1.0 / SUM(impressions_${suffix}) + 1 END`;
-		default: throw new Error(`[archetype-sql] unknown metric: ${metric}`);
-	}
-}
-function deviceUnpivotSql(metrics, whereSql, byDate) {
-	const dateCol = byDate ? "date, " : "";
-	const dateGroup = byDate ? " GROUP BY date" : "";
-	return DEVICE_VALUES.map((dv) => {
-		const suffix = DEVICE_SUFFIX[dv];
-		const mcols = metrics.map((m) => `${deviceMetricExpr(m, suffix)} AS ${m}`).join(", ");
-		return `SELECT ${dateCol}'${dv}' AS device, ${mcols} FROM dates WHERE ${whereSql}${dateGroup}`;
-	}).join(" UNION ALL ");
-}
-function rangePredicate(q) {
-	return {
-		sql: "date BETWEEN ? AND ?",
-		params: [q.range.start, q.range.end]
-	};
-}
-function compareRangePredicate(q) {
-	if (!q.compareRange) return null;
-	return {
-		sql: "date BETWEEN ? AND ?",
-		params: [q.compareRange.start, q.compareRange.end]
-	};
-}
-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}`,
-			order: `(${curClicks} - ${prevClicks}) DESC`
-		};
-		case "declining": return {
-			where: `${curClicks} < ${prevClicks}`,
-			order: `(${curClicks} - ${prevClicks}) ASC`
-		};
-		case "new": return {
-			where: `${prevImpr} = 0 AND ${curImpr} > 0`,
-			order: `${curClicks} DESC, ${curImpr} DESC`
-		};
-		case "lost": return {
-			where: `${curImpr} = 0 AND ${prevImpr} > 0`,
-			order: `${prevImpr} DESC`
-		};
-		default: throw new Error(`[archetype-sql] unknown movers mode: ${movers}`);
-	}
-}
-function facetPredicate(query, table) {
-	const facets = query.facets;
-	if (!facets?.length) return {
-		sql: "",
-		params: []
-	};
-	const parts = [];
-	const params = [];
-	for (const f of facets) {
-		const col = dimExpr(f.column, table);
-		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 compileArchetypeSql(query) {
-	switch (query.archetype) {
-		case "site-daily-timeseries": {
-			const table = "dates";
-			const where = rangePredicate(query);
-			return {
-				table,
-				sql: `SELECT date, ${query.metrics.map((m) => `${metricExpr(m)} AS ${m}`).join(", ")} FROM ${table} WHERE ${where.sql} GROUP BY date ORDER BY date`,
-				params: where.params
-			};
-		}
-		case "entity-daily-timeseries": {
-			const table = tableForDimensions([query.entity.dimension]);
-			const col = dimExpr(query.entity.dimension, table);
-			const where = rangePredicate(query);
-			return {
-				table,
-				sql: `SELECT date, ${metricSelectList(query.metrics)} FROM ${table} WHERE ${where.sql} AND ${col} = ? GROUP BY date ORDER BY date`,
-				params: [...where.params, query.entity.value]
-			};
-		}
-		case "entity-daily-sparkline": {
-			const table = tableForDimensions([query.dimension]);
-			const col = dimExpr(query.dimension, table);
-			const where = rangePredicate(query);
-			if (query.entities.length === 0) throw new Error("[archetype-sql] entity-daily-sparkline requires resolved entities");
-			const placeholders = query.entities.map(() => "?").join(", ");
-			return {
-				table,
-				sql: `SELECT ${col} AS entity, date, ${metricExpr(query.metric)} AS ${query.metric} FROM ${table} WHERE ${where.sql} AND ${col} IN (${placeholders}) GROUP BY ${col}, date ORDER BY ${col}, date`,
-				params: [...where.params, ...query.entities]
-			};
-		}
-		case "top-n-breakdown": {
-			const table = tableForTopNBreakdown(query);
-			const where = rangePredicate(query);
-			const cmp = compareRangePredicate(query);
-			const dir = query.orderBy.dir === "asc" ? "ASC" : "DESC";
-			const compareOrder = `COALESCE(c.${query.orderBy.metric}, 0) ${dir}`;
-			const metricList = query.metrics.includes(query.orderBy.metric) ? query.metrics : [...query.metrics, query.orderBy.metric];
-			const variantSel = query.dimension === "queryCanonical" ? ", COUNT(DISTINCT query) AS variantCount" : "";
-			if (query.dimension === "device") {
-				if (cmp) {
-					const curCols = metricList.map((m) => coalesceMetric(m, "c", m)).join(", ");
-					const prevCols = STD_METRICS.map((m) => coalesceMetric(m, "p", prevAlias(m))).join(", ");
-					let sql = `WITH cur AS (${deviceUnpivotSql(metricList, where.sql, false)}), prev AS (${deviceUnpivotSql(STD_METRICS, cmp.sql, false)}) SELECT COALESCE(c.device, p.device) AS device, ${curCols}, ${prevCols} FROM cur c FULL OUTER JOIN prev p ON c.device = p.device ORDER BY ${compareOrder} LIMIT ?`;
-					const params = [
-						...where.params,
-						...where.params,
-						...where.params,
-						...cmp.params,
-						...cmp.params,
-						...cmp.params,
-						query.limit
-					];
-					if (query.offset && query.offset > 0) {
-						sql += " OFFSET ?";
-						params.push(query.offset);
-					}
-					return {
-						table,
-						sql,
-						params
-					};
-				}
-				let sql = `SELECT device, ${metricList.join(", ")} FROM (${deviceUnpivotSql(metricList, where.sql, false)}) ORDER BY ${query.orderBy.metric} ${dir} LIMIT ?`;
-				const params = [
-					...where.params,
-					...where.params,
-					...where.params,
-					query.limit
-				];
-				if (query.offset && query.offset > 0) {
-					sql += " OFFSET ?";
-					params.push(query.offset);
-				}
-				return {
-					table,
-					sql,
-					params
-				};
-			}
-			const col = dimExpr(query.dimension, table);
-			const facet = facetPredicate(query, table);
-			const totalCol = query.includeTotal ? ", COUNT(*) OVER() AS __total" : "";
-			if (cmp) {
-				const curCols = metricList.map((m) => coalesceMetric(m, "c", m)).join(", ");
-				const prevCols = STD_METRICS.map((m) => coalesceMetric(m, "p", prevAlias(m))).join(", ");
-				const variantOut = query.dimension === "queryCanonical" ? ", c.variantCount AS variantCount" : "";
-				const mover = query.movers ? moverClause(query.movers) : null;
-				const moverWhere = mover ? `WHERE ${mover.where} ` : "";
-				const orderSql = mover ? mover.order : compareOrder;
-				let sql = `WITH cur AS (SELECT ${col} AS k, ${metricSelectList(metricList)}${variantSel} FROM ${table} WHERE ${where.sql}${facet.sql} GROUP BY ${col}), prev AS (SELECT ${col} AS k, ${metricSelectList(STD_METRICS)} FROM ${table} WHERE ${cmp.sql}${facet.sql} GROUP BY ${col}) SELECT COALESCE(c.k, p.k) AS ${query.dimension}, ${curCols}, ${prevCols}${variantOut}${totalCol} FROM cur c FULL OUTER JOIN prev p ON c.k = p.k ${moverWhere}ORDER BY ${orderSql} LIMIT ?`;
-				const params = [
-					...where.params,
-					...facet.params,
-					...cmp.params,
-					...facet.params,
-					query.limit
-				];
-				if (query.offset && query.offset > 0) {
-					sql += " OFFSET ?";
-					params.push(query.offset);
-				}
-				return {
-					table,
-					sql,
-					params
-				};
-			}
-			let sql = `SELECT ${col} AS ${query.dimension}, ${metricSelectList(query.metrics)}${variantSel}${totalCol} FROM ${table} WHERE ${where.sql}${facet.sql} GROUP BY ${col} ORDER BY ${query.orderBy.metric} ${dir} LIMIT ?`;
-			const params = [
-				...where.params,
-				...facet.params,
-				query.limit
-			];
-			if (query.offset && query.offset > 0) {
-				sql += " OFFSET ?";
-				params.push(query.offset);
-			}
-			return {
-				table,
-				sql,
-				params
-			};
-		}
-		case "single-row-lookup": {
-			const table = tableForDimensions(Object.keys(query.match));
-			const where = rangePredicate(query);
-			const matchParts = [];
-			const matchParams = [];
-			for (const [dim, value] of Object.entries(query.match)) {
-				const col = dimExpr(dim, table);
-				if (!col) throw new Error(`[archetype-sql] single-row-lookup: unknown dimension ${dim}`);
-				matchParts.push(`${col} = ?`);
-				matchParams.push(value);
-			}
-			const matchSql = matchParts.length ? ` AND ${matchParts.join(" AND ")}` : "";
-			return {
-				table,
-				sql: `SELECT ${metricSelectList(query.metrics)} FROM ${table} WHERE ${where.sql}${matchSql}`,
-				params: [...where.params, ...matchParams]
-			};
-		}
-		case "multi-series-stacked-daily": {
-			const table = tableForDimensions([query.seriesDimension]);
-			const where = rangePredicate(query);
-			if (query.seriesDimension === "device") return {
-				table,
-				sql: `SELECT date, device, ${query.metric} FROM (${deviceUnpivotSql([query.metric], where.sql, true)}) ORDER BY date, device`,
-				params: [
-					...where.params,
-					...where.params,
-					...where.params
-				]
-			};
-			const col = dimExpr(query.seriesDimension, table);
-			return {
-				table,
-				sql: `SELECT date, ${col} AS ${query.seriesDimension}, ${metricExpr(query.metric)} AS ${query.metric} FROM ${table} WHERE ${where.sql} GROUP BY date, ${col} ORDER BY date, ${col}`,
-				params: where.params
-			};
-		}
-		case "two-dimension-detail": {
-			const table = "page_queries";
-			const where = rangePredicate(query);
-			const facet = facetPredicate(query, table);
-			const filterParts = [];
-			const filterParams = [];
-			if (query.filter?.page) {
-				filterParts.push("url = ?");
-				filterParams.push(query.filter.page);
-			}
-			if (query.filter?.query) {
-				filterParts.push("query = ?");
-				filterParams.push(query.filter.query);
-			}
-			const filterSql = filterParts.length ? ` AND ${filterParts.join(" AND ")}` : "";
-			let sql = `SELECT url AS page, query, ${metricSelectList(query.metrics)} FROM ${table} WHERE ${where.sql}${filterSql}${facet.sql} GROUP BY url, query`;
-			const params = [
-				...where.params,
-				...filterParams,
-				...facet.params
-			];
-			if (query.orderBy) {
-				const dir = query.orderBy.dir === "asc" ? "ASC" : "DESC";
-				sql += ` ORDER BY ${query.orderBy.metric} ${dir}`;
-			}
-			if (typeof query.limit === "number") {
-				sql += " LIMIT ?";
-				params.push(query.limit);
-			}
-			return {
-				table,
-				sql,
-				params
-			};
-		}
-		case "arbitrary-sql": return {
-			table: "page_queries",
-			sql: query.sql,
-			params: [...query.params ?? []]
-		};
-		case "aux-cloud-only": throw new Error("[archetype-sql] aux-cloud-only is not an Iceberg query — route to the cloud endpoint");
-		default: throw new Error(`[archetype-sql] unhandled archetype: ${query.archetype}`);
-	}
-}
-function tableForArchetype(query) {
-	if (query.archetype === "aux-cloud-only") return null;
-	return compileArchetypeSql(query).table;
-}
-async function createClient(db, conn) {
-	return {
-		db,
-		conn,
-		async query(sql, params = []) {
-			if (params.length === 0) return arrowToRows(await conn.query(sql));
-			const stmt = await conn.prepare(sql);
-			try {
-				return arrowToRows(await stmt.query(...params));
-			} finally {
-				await stmt.close();
-			}
-		},
-		async close() {
-			await conn.close();
-		}
-	};
-}
-var DuckDBWasmSession = class extends PgAsyncSession {
-	client;
-	options;
-	static [entityKind] = "DuckDBWasmSession";
-	logger;
-	cache;
-	constructor(client, dialect, options = {}) {
-		super(dialect);
-		this.client = client;
-		this.options = options;
-		this.logger = options.logger ?? new NoopLogger();
-		this.cache = options.cache;
-	}
-	prepareQuery(query, mode, _name, mapper, queryMetadata, cacheConfig) {
-		const client = this.client;
-		const executor = async (params = []) => {
-			const rows = await (await client).query(query.sql, params);
-			return mode === "arrays" ? rows.map((row) => Object.values(row)) : rows;
-		};
-		return new PgAsyncPreparedQuery(executor, query, mapper, mode, this.logger, this.cache, queryMetadata, cacheConfig);
-	}
-	transaction() {
-		throw new Error("Transactions are not supported by the DuckDB-WASM drizzle adapter. The analytics workload is read-only; if transactions become necessary, implement PgAsyncSession.transaction() in @gscdump/engine-duckdb-wasm.");
-	}
-};
-var DuckDBWasmDatabase = class extends PgAsyncDatabase {
-	static [entityKind] = "DuckDBWasmDatabase";
-};
-function drizzle(client, config = {}) {
-	const dialect = new PgDialect();
-	const clientPromise = Promise.resolve(client);
-	let logger;
-	if (config.logger === true) logger = new DefaultLogger();
-	else if (config.logger !== false) logger = config.logger;
-	const db = new DuckDBWasmDatabase(dialect, new DuckDBWasmSession(clientPromise, dialect, {
-		logger,
-		cache: config.cache
-	}), config.relations ?? (config.schema ? buildRelations(config.schema, {}) : {}));
-	db.$client = clientPromise;
-	return db;
-}
-function createOpfsHandleRegistry(backend) {
-	const entries = /* @__PURE__ */ new Map();
-	const pending = /* @__PURE__ */ new Map();
-	function reportCleanupFailure(operation, error) {
-		console.warn(`[gscdump/engine-duckdb-wasm] ${operation} failed`, error);
-	}
-	async function acquire(name, openHandle) {
-		const existing = entries.get(name);
-		if (existing) {
-			existing.refs++;
-			return;
-		}
-		const inflight = pending.get(name);
-		if (inflight) {
-			await inflight.then(() => void 0, () => void 0);
-			const settled = entries.get(name);
-			if (settled) {
-				settled.refs++;
-				return;
-			}
-			return acquire(name, openHandle);
-		}
-		const registration = (async () => {
-			const handle = await openHandle();
-			await backend.register(name, handle);
-			entries.set(name, {
-				handle,
-				refs: 1
-			});
-		})();
-		pending.set(name, registration);
-		try {
-			await registration;
-		} finally {
-			pending.delete(name);
-		}
-	}
-	async function release(names) {
-		for (const name of names) {
-			const entry = entries.get(name);
-			if (!entry) continue;
-			entry.refs--;
-			if (entry.refs > 0) continue;
-			entries.delete(name);
-			await backend.drop(name).catch((error) => {
-				reportCleanupFailure(`dropping OPFS handle ${name}`, error);
-			});
-		}
-	}
-	const viewRefs = /* @__PURE__ */ new Map();
-	function acquireView(key, signature) {
-		const existing = viewRefs.get(key);
-		if (existing) {
-			if (existing.signature !== signature) throw new Error(`view ${key} is already attached with a different signature`);
-			existing.refs++;
-			return;
-		}
-		viewRefs.set(key, {
-			refs: 1,
-			signature
-		});
-	}
-	async function releaseView(key, drop) {
-		const existing = viewRefs.get(key);
-		const next = (existing?.refs ?? 0) - 1;
-		if (next > 0) {
-			viewRefs.set(key, {
-				refs: next,
-				signature: existing?.signature
-			});
-			return;
-		}
-		viewRefs.delete(key);
-		await drop().catch((error) => {
-			reportCleanupFailure(`dropping view ${key}`, error);
-		});
-	}
-	return {
-		acquire,
-		release,
-		size: () => entries.size,
-		refs: (name) => entries.get(name)?.refs ?? 0,
-		acquireView,
-		releaseView,
-		viewRefs: (key) => viewRefs.get(key)?.refs ?? 0,
-		viewSignature: (key) => viewRefs.get(key)?.signature
-	};
-}
-function overlayViewBody(args) {
-	const { lakeSelect, overlaySelect } = args;
-	const materialize = args.materializeLake ?? true;
-	if (!lakeSelect && !overlaySelect) return null;
-	if (!overlaySelect) return lakeSelect;
-	if (!lakeSelect) return overlaySelect;
-	if (materialize) return `WITH lake AS MATERIALIZED (${lakeSelect}), lake_dates AS (SELECT DISTINCT date FROM lake) SELECT * FROM lake UNION ALL BY NAME SELECT * FROM (${overlaySelect}) AS overlay WHERE overlay.date NOT IN (SELECT date FROM lake_dates)`;
-	return `${lakeSelect} UNION ALL BY NAME SELECT * FROM (${overlaySelect}) AS overlay WHERE overlay.date NOT IN (SELECT DISTINCT date FROM (${lakeSelect}))`;
-}
-var OpfsQuotaExceededError = class extends Error {
-	name = "OpfsQuotaExceededError";
-	degradedTables;
-	constructor(message, degradedTables) {
-		super(message);
-		this.degradedTables = degradedTables;
-	}
-};
-const DEFAULT_CONCURRENCY = 2;
-const OPFS_PREFIX = "gscdump-snapshot__";
-const RECOVER_BUFFER_PREFIX = "gscdump-recover__";
-const MAX_CONTENT_HASH_SLUG_CACHE = 4096;
-const contentHashSlugCache = /* @__PURE__ */ new Map();
-const IDENT_RE = /^[A-Z_][\w$]*$/i;
-function nowMs() {
-	return globalThis.performance?.now?.() ?? Date.now();
-}
-function isNotFoundError(error) {
-	return typeof error === "object" && error !== null && error.name === "NotFoundError";
-}
-function reportBestEffortFailure(operation, error) {
-	console.warn(`[gscdump/engine-duckdb-wasm] ${operation} failed`, error);
-}
-async function attemptCleanup(operation, cleanup) {
-	try {
-		await cleanup();
-	} catch (error) {
-		reportBestEffortFailure(operation, error);
-	}
-}
-function emitTiming(onTiming, info) {
-	try {
-		onTiming?.(info);
-	} catch (error) {
-		reportBestEffortFailure("timing callback", error);
-	}
-}
-async function timed(onTiming, stage, meta, fn) {
-	const started = nowMs();
-	try {
-		return await fn();
-	} finally {
-		emitTiming(onTiming, {
-			...meta,
-			stage,
-			durationMs: nowMs() - started
-		});
-	}
-}
-const dbRegistries = /* @__PURE__ */ new WeakMap();
-function getOpfsRegistry(db, protocol) {
-	let registry = dbRegistries.get(db);
-	if (!registry) {
-		registry = createOpfsHandleRegistry({
-			register: (name, handle) => db.registerFileHandle(name, handle, protocol, true),
-			drop: async (name) => {
-				await db.dropFile(name);
-			}
-		});
-		dbRegistries.set(db, registry);
-	}
-	return registry;
-}
-const dbBufferRegistries = /* @__PURE__ */ new WeakMap();
-function getBufferRegistry(db) {
-	let registry = dbBufferRegistries.get(db);
-	if (!registry) {
-		registry = createOpfsHandleRegistry({
-			register: (name, handle) => db.registerFileBuffer(name, handle),
-			drop: async (name) => {
-				await db.dropFile(name);
-			}
-		});
-		dbBufferRegistries.set(db, registry);
-	}
-	return registry;
-}
-function assertSqlIdentifier(kind, value) {
-	if (!IDENT_RE.test(value)) throw new TypeError(`[engine-duckdb-wasm/opfs] invalid ${kind} identifier ${JSON.stringify(value)}`);
-}
-const DOWNLOAD_DEADLINE_MS = 12e4;
-function isQuotaError(err) {
-	if (typeof err !== "object" || err === null) return false;
-	return err.name === "QuotaExceededError" || err.code === 22;
-}
-function isAbortError$1(err) {
-	return typeof err === "object" && err !== null && err.name === "AbortError";
-}
-function isOpfsAccessHandleConflict(err) {
-	const msg = err instanceof Error ? err.message : String(err);
-	return /createSyncAccessHandle|Access Handle/i.test(msg);
-}
-function isOpfsWriteConflict(err) {
-	if (typeof err !== "object" || err === null) return false;
-	const name = err.name;
-	const msg = err instanceof Error ? err.message : String(err);
-	return name === "NoModificationAllowedError" || err.code === 7 || /createWritable|modifications are not allowed/i.test(msg);
-}
-function opfsFileName(table, hashSlug, index) {
-	return hashSlug ? `${OPFS_PREFIX}${table}_${hashSlug}.parquet` : `${OPFS_PREFIX}${table}_${index}.parquet`;
-}
-function escapeRegExp(s) {
-	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function tableEntryMatcher(table) {
-	return new RegExp(`^${escapeRegExp(`${OPFS_PREFIX}${table}_`)}(?:[0-9a-f]{16}|\\d+(?:_[0-9a-f]{16})?)\\.parquet$`);
-}
-async function sweepStaleEntries(root, registry, expectedByTable) {
-	const dir = root;
-	if (!dir.keys) return;
-	const matchers = [...expectedByTable].map(([table, expected]) => ({
-		expected,
-		re: tableEntryMatcher(table)
-	}));
-	for await (const name of dir.keys()) {
-		const m = matchers.find((m) => m.re.test(name));
-		if (!m || m.expected.has(name) || registry.refs(name) > 0) continue;
-		try {
-			await root.removeEntry(name);
-		} catch (error) {
-			if (!isNotFoundError(error)) reportBestEffortFailure(`removing stale OPFS entry ${name}`, error);
-		}
-	}
-}
-async function requestPersistentStorage() {
-	const storage = globalThis.navigator?.storage;
-	if (!storage?.persist) return false;
-	if (await storage.persisted?.().catch(() => false)) return true;
-	return storage.persist().catch(() => false);
-}
-async function estimateOpfsStorage() {
-	const estimate = globalThis.navigator?.storage?.estimate;
-	if (!estimate) return {};
-	const est = await estimate.call(globalThis.navigator.storage).catch(() => null);
-	return est ? {
-		usageBytes: est.usage,
-		quotaBytes: est.quota
-	} : {};
-}
-async function contentHashSlug(contentHash) {
-	const cached = contentHashSlugCache.get(contentHash);
-	if (cached) return cached;
-	if (contentHashSlugCache.size >= MAX_CONTENT_HASH_SLUG_CACHE) {
-		const oldest = contentHashSlugCache.keys().next().value;
-		if (oldest !== void 0) contentHashSlugCache.delete(oldest);
-	}
-	const promise = deriveContentHashSlug(contentHash).catch((err) => {
-		contentHashSlugCache.delete(contentHash);
-		throw err;
-	});
-	contentHashSlugCache.set(contentHash, promise);
-	return promise;
-}
-async function deriveContentHashSlug(contentHash) {
-	const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(contentHash));
-	const bytes = new Uint8Array(digest);
-	let hex = "";
-	for (let i = 0; i < 8; i++) hex += bytes[i].toString(16).padStart(2, "0");
-	return hex;
-}
-async function getOpfsRoot() {
-	const dir = globalThis.navigator?.storage?.getDirectory;
-	if (!dir) throw new Error("[engine-duckdb-wasm/opfs] OPFS unavailable: navigator.storage.getDirectory missing");
-	return dir.call(globalThis.navigator.storage);
-}
-async function readOpfsSnapshotFile(table, contentHash, index, expectedBytes) {
-	try {
-		const root = await getOpfsRoot();
-		const name = opfsFileName(table, contentHash ? await contentHashSlug(contentHash) : void 0, index);
-		const file = await (await root.getFileHandle(name)).getFile();
-		if (file.size !== expectedBytes) return null;
-		return new Uint8Array(await file.arrayBuffer());
-	} catch (error) {
-		if (!isNotFoundError(error)) reportBestEffortFailure(`reading OPFS snapshot ${table}`, error);
-		return null;
-	}
-}
-async function materialiseFile(root, name, file, fetchImpl, fetchInit, signal) {
-	signal?.throwIfAborted();
-	let handle;
-	try {
-		handle = await root.getFileHandle(name);
-		if ((await handle.getFile()).size === file.bytes) return {
-			handle,
-			outcome: "cache-hit"
-		};
-	} catch (error) {
-		if (!isNotFoundError(error)) throw error;
-	}
-	signal?.throwIfAborted();
-	const deadline = AbortSignal.timeout(DOWNLOAD_DEADLINE_MS);
-	const fetchSignal = signal ? AbortSignal.any([signal, deadline]) : deadline;
-	const resp = await fetchImpl(file.url, {
-		...fetchInit,
-		signal: fetchSignal
-	});
-	if (!resp.ok) throw new Error(`[engine-duckdb-wasm/opfs] download ${file.url} failed: ${resp.status}`);
-	handle = await root.getFileHandle(name, { create: true });
-	let writable;
-	try {
-		writable = await handle.createWritable();
-	} catch (err) {
-		await resp.body?.cancel().catch(() => void 0);
-		throw err;
-	}
-	let reader;
-	let bytesWritten = 0;
-	try {
-		if (resp.body) {
-			reader = resp.body.getReader();
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				bytesWritten += value.byteLength;
-				if (bytesWritten > file.bytes) throw new Error(`[engine-duckdb-wasm/opfs] download ${file.url} byte length mismatch: expected ${file.bytes}, got more than ${file.bytes}`);
-				await writable.write(value);
-			}
-		} else {
-			const buf = await resp.arrayBuffer();
-			bytesWritten = buf.byteLength;
-			await writable.write(buf);
-		}
-		if (bytesWritten !== file.bytes) throw new Error(`[engine-duckdb-wasm/opfs] download ${file.url} byte length mismatch: expected ${file.bytes}, got ${bytesWritten}`);
-		await writable.close();
-	} catch (err) {
-		await reader?.cancel().catch(() => void 0);
-		if (writable.abort) await attemptCleanup(`aborting partial OPFS write ${name}`, () => writable.abort());
-		await attemptCleanup(`removing partial OPFS file ${name}`, () => root.removeEntry(name));
-		throw err;
-	} finally {
-		reader?.releaseLock();
-	}
-	return {
-		handle,
-		outcome: "downloaded"
-	};
-}
-function quoteList(files) {
-	return files.map((f) => `'${f.replace(/'/g, "''")}'`).join(", ");
-}
-function lakeSelect(files) {
-	return `SELECT * REPLACE (CAST(date AS DATE) AS date) FROM read_parquet([${quoteList(files)}], union_by_name = true)`;
-}
-function readParquetViewSql$1(schema, table, files) {
-	return `CREATE OR REPLACE VIEW ${schema}.${table} AS ${lakeSelect(files)}`;
-}
-function readParquetViewWithOverlaySql(schema, table, lakeFiles, overlayFile) {
-	const overlay = `SELECT * REPLACE (CAST(date AS DATE) AS date) FROM read_parquet(['${overlayFile.replace(/'/g, "''")}'], union_by_name = true)`;
-	return `CREATE OR REPLACE VIEW ${schema}.${table} AS ${overlayViewBody({
-		lakeSelect: lakeFiles.length === 0 ? null : lakeSelect(lakeFiles),
-		overlaySelect: overlay,
-		materializeLake: false
-	})}`;
-}
-function viewKey(schema, table) {
-	return `${schema}.${table}`;
-}
-function viewSignature(lakeFiles, overlayFile) {
-	return JSON.stringify({
-		lake: [...lakeFiles].sort(),
-		overlay: overlayFile ?? null
-	});
-}
-async function ensureView(registry, conn, schema, table, signature, sql) {
-	const key = viewKey(schema, table);
-	if (registry.viewSignature(key) === signature) {
-		registry.acquireView(key, signature);
-		return;
-	}
-	if (registry.viewRefs(key) > 0) throw new Error(`[engine-duckdb-wasm/opfs] view ${key} is already attached with a different fileset`);
-	await conn.query(sql);
-	registry.acquireView(key, signature);
-}
-async function recoveredBufferName(table, file, index) {
-	const slug = file.contentHash ? await contentHashSlug(file.contentHash) : String(index);
-	return `${RECOVER_BUFFER_PREFIX}${table}_${slug}.parquet`;
-}
-async function runWithConcurrency$1(items, concurrency, fn) {
-	let next = 0;
-	let failed;
-	async function worker() {
-		while (failed === void 0 && next < items.length) {
-			const index = next++;
-			try {
-				await fn(items[index], index);
-			} catch (err) {
-				failed = err;
-				throw err;
-			}
-		}
-	}
-	const rejected = (await Promise.allSettled(Array.from({ length: Math.min(concurrency, items.length) }, worker))).find((r) => r.status === "rejected");
-	if (rejected) throw rejected.reason;
-}
-async function attachOpfsParquetTables(options) {
-	const { db, conn, tables, schema = "main", fetch: fetchImpl = globalThis.fetch.bind(globalThis), fetchInit, fetchConcurrency = DEFAULT_CONCURRENCY, signal, version, onFileProgress, onTiming, withDb = (fn) => fn(), recoverContention = true } = options;
-	assertSqlIdentifier("schema", schema);
-	for (const table of tables) assertSqlIdentifier("table", table.table);
-	const totalStarted = nowMs();
-	await timed(onTiming, "persist", {}, requestPersistentStorage);
-	const root = await timed(onTiming, "root", {}, getOpfsRoot);
-	const flat = [];
-	const expectedByTable = /* @__PURE__ */ new Map();
-	await timed(onTiming, "plan", { tables: tables.length }, async () => {
-		for (const t of tables) {
-			const expected = /* @__PURE__ */ new Set();
-			for (let i = 0; i < t.files.length; i++) {
-				const file = t.files[i];
-				const slug = file.contentHash ? await contentHashSlug(file.contentHash) : void 0;
-				const name = opfsFileName(t.table, slug, i);
-				flat.push({
-					table: t.table,
-					file,
-					name
-				});
-				expected.add(name);
-			}
-			if (t.overlay) {
-				const slug = t.overlay.contentHash ? await contentHashSlug(t.overlay.contentHash) : void 0;
-				const name = opfsFileName(t.table, slug, t.files.length);
-				flat.push({
-					table: t.table,
-					file: t.overlay,
-					name,
-					overlay: true
-				});
-				expected.add(name);
-			}
-			expectedByTable.set(t.table, expected);
-		}
-	});
-	const total = flat.length;
-	const overlayNames = /* @__PURE__ */ new Map();
-	const expectedCount = new Map(tables.map((t) => [t.table, t.files.length + (t.overlay ? 1 : 0)]));
-	const { DuckDBDataProtocol } = await timed(onTiming, "duckdb-import", {}, () => import("@duckdb/duckdb-wasm"));
-	const registry = getOpfsRegistry(db, DuckDBDataProtocol.BROWSER_FSACCESS);
-	const bufferRegistry = getBufferRegistry(db);
-	await timed(onTiming, "sweep", {
-		files: total,
-		tables: tables.length
-	}, () => sweepStaleEntries(root, registry, expectedByTable)).catch((error) => {
-		reportBestEffortFailure("stale OPFS cache sweep", error);
-	});
-	const tableFiles = /* @__PURE__ */ new Map();
-	const degraded = /* @__PURE__ */ new Set();
-	const degradeReason = /* @__PURE__ */ new Map();
-	const acquiredNames = /* @__PURE__ */ new Set();
-	const bufferFiles = [];
-	const bufferViews = [];
-	let bytesAttached = 0;
-	const releaseTable = async (table) => {
-		const names = (tableFiles.get(table) ?? []).map((f) => f.name);
-		for (const n of names) acquiredNames.delete(n);
-		await withDb(() => registry.release(names));
-	};
-	const runDownloads = () => runWithConcurrency$1(flat, Math.max(1, fetchConcurrency), async (item, index) => {
-		if (degraded.has(item.table)) return;
-		signal?.throwIfAborted();
-		const fileStarted = nowMs();
-		const name = item.name;
-		let result;
-		let materialiseMs = 0;
-		let registerMs = 0;
-		try {
-			const materialiseStarted = nowMs();
-			result = await materialiseFile(root, name, item.file, fetchImpl, fetchInit, signal);
-			materialiseMs = nowMs() - materialiseStarted;
-			emitTiming(onTiming, {
-				stage: "materialise",
-				durationMs: materialiseMs,
-				table: item.table,
-				file: name,
-				bytes: item.file.bytes,
-				outcome: result.outcome
-			});
-		} catch (err) {
-			if (isAbortError$1(err)) throw err;
-			if (isQuotaError(err)) {
-				degraded.add(item.table);
-				degradeReason.set(item.table, "quota");
-				return;
-			}
-			if (isOpfsWriteConflict(err)) {
-				degraded.add(item.table);
-				degradeReason.set(item.table, "contention");
-				return;
-			}
-			throw err;
-		}
-		try {
-			const registerStarted = nowMs();
-			await withDb(() => registry.acquire(name, () => result.handle));
-			registerMs = nowMs() - registerStarted;
-			emitTiming(onTiming, {
-				stage: "register",
-				durationMs: registerMs,
-				table: item.table,
-				file: name,
-				bytes: item.file.bytes,
-				outcome: result.outcome
-			});
-			acquiredNames.add(name);
-		} catch (err) {
-			if (isAbortError$1(err)) throw err;
-			if (isOpfsAccessHandleConflict(err)) {
-				degraded.add(item.table);
-				degradeReason.set(item.table, "contention");
-				return;
-			}
-			throw err;
-		}
-		const list = tableFiles.get(item.table) ?? [];
-		list.push({
-			name,
-			handle: result.handle
-		});
-		tableFiles.set(item.table, list);
-		if (item.overlay) overlayNames.set(item.table, name);
-		bytesAttached += item.file.bytes;
-		onFileProgress?.({
-			table: item.table,
-			file: name,
-			index,
-			total,
-			bytes: item.file.bytes,
-			outcome: result.outcome,
-			materialiseMs,
-			registerMs,
-			totalMs: nowMs() - fileStarted
-		});
-	});
-	try {
-		await timed(onTiming, "downloads", {
-			files: total,
-			tables: tables.length
-		}, runDownloads);
-	} catch (err) {
-		await attemptCleanup("releasing handles after download failure", () => withDb(() => registry.release([...acquiredNames])));
-		throw err;
-	}
-	const attached = [];
-	const registeredNames = [];
-	for (const t of tables) {
-		if (degraded.has(t.table)) {
-			await releaseTable(t.table);
-			continue;
-		}
-		const files = tableFiles.get(t.table) ?? [];
-		if (files.length !== (expectedCount.get(t.table) ?? t.files.length)) {
-			degraded.add(t.table);
-			degradeReason.set(t.table, degradeReason.get(t.table) ?? "incomplete");
-			await releaseTable(t.table);
-			continue;
-		}
-		const overlayName = overlayNames.get(t.table);
-		const lakeNames = (overlayName ? files.map((f) => f.name).filter((n) => n !== overlayName) : files.map((f) => f.name)).sort();
-		const signature = viewSignature(lakeNames, overlayName);
-		try {
-			signal?.throwIfAborted();
-			await timed(onTiming, "view", {
-				table: t.table,
-				files: files.length
-			}, () => withDb(() => ensureView(registry, conn, schema, t.table, signature, overlayName ? readParquetViewWithOverlaySql(schema, t.table, lakeNames, overlayName) : readParquetViewSql$1(schema, t.table, lakeNames))));
-		} catch (err) {
-			if (isAbortError$1(err)) {
-				await attemptCleanup("detaching OPFS resources after abort", () => withDb(() => detachOpfs(registry, conn, schema, attached, [...acquiredNames])));
-				throw err;
-			}
-			if (isOpfsAccessHandleConflict(err)) {
-				if (registry.viewRefs(viewKey(schema, t.table)) === 0) await attemptCleanup(`dropping incomplete view ${schema}.${t.table}`, () => withDb(() => conn.query(`DROP VIEW IF EXISTS ${schema}.${t.table}`)));
-				degraded.add(t.table);
-				degradeReason.set(t.table, "contention");
-				await releaseTable(t.table);
-				continue;
-			}
-			await attemptCleanup("detaching OPFS resources after view failure", () => withDb(() => detachOpfs(registry, conn, schema, attached, [...acquiredNames])));
-			throw err;
-		}
-		attached.push(t.table);
-		for (const f of files) registeredNames.push(f.name);
-	}
-	const recoverTableToBuffers = async (t) => {
-		return timed(onTiming, "recovery", {
-			table: t.table,
-			files: t.files.length + (t.overlay ? 1 : 0)
-		}, async () => {
-			const readOne = async (file, index) => {
-				const cached = await readOpfsSnapshotFile(t.table, file.contentHash, index, file.bytes);
-				if (cached) return cached;
-				signal?.throwIfAborted();
-				const resp = await fetchImpl(file.url, {
-					...fetchInit,
-					signal
-				});
-				if (!resp.ok) throw new Error(`[engine-duckdb-wasm/opfs] recover ${file.url} failed: ${resp.status}`);
-				return new Uint8Array(await resp.arrayBuffer());
-			};
-			const lakeNames = [];
-			for (let i = 0; i < t.files.length; i++) {
-				const file = t.files[i];
-				const name = await recoveredBufferName(t.table, file, i);
-				const buf = await readOne(file, i);
-				await withDb(() => bufferRegistry.acquire(name, () => buf));
-				bufferFiles.push(name);
-				lakeNames.push(name);
-				bytesAttached += file.bytes;
-			}
-			let overlayName;
-			if (t.overlay) {
-				overlayName = await recoveredBufferName(t.table, t.overlay, t.files.length);
-				const buf = await readOne(t.overlay, t.files.length);
-				await withDb(() => bufferRegistry.acquire(overlayName, () => buf));
-				bufferFiles.push(overlayName);
-				bytesAttached += t.overlay.bytes;
-			}
-			lakeNames.sort();
-			const body = overlayViewBody({
-				lakeSelect: lakeNames.length ? lakeSelect(lakeNames) : null,
-				overlaySelect: overlayName ? `SELECT * REPLACE (CAST(date AS DATE) AS date) FROM read_parquet(['${overlayName.replace(/'/g, "''")}'], union_by_name = true)` : null,
-				materializeLake: false
-			});
-			if (!body) return false;
-			await withDb(() => ensureView(registry, conn, schema, t.table, viewSignature(lakeNames, overlayName), `CREATE OR REPLACE VIEW ${schema}.${t.table} AS ${body}`));
-			bufferViews.push(t.table);
-			return true;
-		});
-	};
-	if (recoverContention && !signal?.aborted) for (const t of tables) {
-		if (!degraded.has(t.table) || degradeReason.get(t.table) !== "contention") continue;
-		const before = bufferFiles.length;
-		if (await recoverTableToBuffers(t).catch(() => false)) degraded.delete(t.table);
-		else {
-			await attemptCleanup(`releasing recovery buffers for ${t.table}`, () => withDb(() => bufferRegistry.release(bufferFiles.slice(before))));
-			bufferFiles.length = before;
-		}
-	}
-	emitTiming(onTiming, {
-		stage: "total",
-		durationMs: nowMs() - totalStarted,
-		files: total,
-		tables: tables.length,
-		bytes: bytesAttached
-	});
-	let detached = false;
-	return {
-		version,
-		tables: [...attached, ...bufferViews],
-		schema,
-		bytesAttached,
-		degradedTables: [...degraded],
-		degradeReasons: Object.fromEntries(degradeReason),
-		async detach() {
-			if (detached) return;
-			detached = true;
-			await detachOpfs(registry, conn, schema, attached, registeredNames);
-			for (const v of bufferViews) await registry.releaseView(viewKey(schema, v), () => conn.query(`DROP VIEW IF EXISTS ${schema}.${v}`).then(() => {}));
-			await bufferRegistry.release(bufferFiles);
-		}
-	};
-}
-async function detachOpfs(registry, conn, schema, tables, files) {
-	for (const table of tables) await registry.releaseView(`${schema}.${table}`, () => conn.query(`DROP VIEW IF EXISTS ${schema}.${table}`).then(() => {}));
-	await registry.release(files);
-}
-async function clearOpfsSnapshotCache() {
-	const root = await getOpfsRoot().catch((error) => {
-		reportBestEffortFailure("opening OPFS cache for clearing", error);
-		return null;
-	});
-	if (!root) return;
-	const removable = [];
-	const dir = root;
-	if (dir.keys) {
-		for await (const name of dir.keys()) if (name.startsWith(OPFS_PREFIX)) removable.push(name);
-	}
-	for (const name of removable) try {
-		await root.removeEntry(name);
-	} catch (error) {
-		if (!isNotFoundError(error)) reportBestEffortFailure(`clearing OPFS cache entry ${name}`, error);
-	}
-}
-async function createInsightRunner(opts) {
-	const client = await createClient(opts.db, opts.conn);
-	const clientPromise = Promise.resolve(client);
-	return {
-		db: drizzle(clientPromise, {
-			schema,
-			logger: opts.logger
-		}),
-		client: clientPromise,
-		close: () => client.close()
-	};
-}
-const { scopeFor, mergeScope } = createScopedHelpers(schema);
-const DEFAULT_ATTACH_FETCH_CONCURRENCY = 2;
-const DEFAULT_ATTACH_MAX_FILES = 32;
-const DEFAULT_ATTACH_MAX_BYTES = 16 * 1024 * 1024;
-let nextAttachId = 0;
-var BrowserAttachBudgetExceededError = class extends Error {
-	name = "BrowserAttachBudgetExceededError";
-};
-const browserAttachErrors = {
-	maxFilesExceeded(files, maxFiles) {
-		return {
-			kind: "browser-attach-budget-exceeded",
-			budget: "maxFiles",
-			message: `browser parquet attach requires ${files} files, above maxFiles=${maxFiles}`
-		};
-	},
-	hintedBytesExceeded(hintedBytes, maxBytes) {
-		return {
-			kind: "browser-attach-budget-exceeded",
-			budget: "maxBytes",
-			message: `browser parquet attach requires ${hintedBytes} hinted bytes, above maxBytes=${maxBytes}`
-		};
-	},
-	plannedBytesExceeded(plannedBytes, maxBytes) {
-		return {
-			kind: "browser-attach-budget-exceeded",
-			budget: "maxBytes",
-			message: `browser parquet attach planned ${plannedBytes} bytes, above maxBytes=${maxBytes}`
-		};
-	}
-};
-function isBrowserAttachError(value) {
-	return typeof value === "object" && value !== null && value.kind === "browser-attach-budget-exceeded" && typeof value.message === "string";
-}
-function browserAttachErrorToException(error) {
-	const exception = new BrowserAttachBudgetExceededError(error.message);
-	exception.browserAttachError = error;
-	return exception;
-}
-function fileName(table, index, provided) {
-	return provided ?? `${table}_${index}.parquet`;
-}
-function attachFileName(attachId, table, index) {
-	return `__gscdump_attach_${attachId}_${fileName(table, index)}`;
-}
-function readParquetViewSql(schema, table, files) {
-	return `CREATE OR REPLACE VIEW ${schema}.${table} AS SELECT * REPLACE (CAST(date AS DATE) AS date) FROM read_parquet([${files.map((name) => `'${sqlEscape(name)}'`).join(", ")}], union_by_name = true)`;
-}
-function positiveInteger(value, fallback, label) {
-	const raw = value ?? fallback;
-	if (!Number.isFinite(raw) || raw < 1) throw new Error(`${label} must be a positive integer`);
-	return Math.floor(raw);
-}
-async function runWithConcurrency(items, concurrency, fn) {
-	let next = 0;
-	let failed = false;
-	async function worker() {
-		while (!failed && next < items.length) {
-			const index = next++;
-			try {
-				await fn(items[index], index);
-			} catch (err) {
-				failed = true;
-				throw err;
-			}
-		}
-	}
-	const rejected = (await Promise.allSettled(Array.from({ length: Math.min(concurrency, items.length) }, worker))).find((result) => result.status === "rejected");
-	if (rejected) throw rejected.reason;
-}
-function sizeHintFromUrl(url) {
-	try {
-		const base = typeof globalThis.location?.href === "string" ? globalThis.location.href : "http://localhost";
-		const raw = new URL(url, base).searchParams.get("s")?.split(".")[0];
-		if (!raw) return null;
-		const size = Number(raw);
-		return Number.isFinite(size) && size >= 0 ? size : null;
-	} catch {
-		return null;
-	}
-}
-function mergeAbortSignals(primary, secondary) {
-	if (!primary) return secondary;
-	if (!secondary) return primary;
-	if (primary.aborted) return primary;
-	if (secondary.aborted) return secondary;
-	const controller = new AbortController();
-	const abort = (signal) => {
-		controller.abort(signal.reason);
-	};
-	primary.addEventListener("abort", () => abort(primary), { once: true });
-	secondary.addEventListener("abort", () => abort(secondary), { once: true });
-	return controller.signal;
-}
-function fetchInitFor(fetchInit, method, signal, extraHeaders) {
-	const { body: _body, method: _method, signal: initSignal, headers: initHeaders, ...rest } = fetchInit ?? {};
-	const headers = new Headers(initHeaders);
-	for (const [key, value] of Object.entries(extraHeaders ?? {})) headers.set(key, value);
-	return {
-		...rest,
-		method,
-		headers,
-		signal: mergeAbortSignals(signal, initSignal ?? void 0)
-	};
-}
-function isAbortError(err) {
-	return typeof err === "object" && err !== null && err.name === "AbortError";
-}
-function parseContentLength(headers) {
-	const raw = headers.get("content-length");
-	if (!raw) return null;
-	const size = Number(raw);
-	return Number.isFinite(size) && size >= 0 ? size : null;
-}
-function parseContentRangeSize(headers) {
-	const raw = headers.get("content-range");
-	if (!raw) return null;
-	const match = /^bytes\s+\d+-\d+\/(\d+)$/i.exec(raw);
-	if (!match) return null;
-	const size = Number(match[1]);
-	return Number.isFinite(size) && size >= 0 ? size : null;
-}
-function supportsRangeReads(headers) {
-	return headers.get("accept-ranges")?.toLowerCase().split(",").map((v) => v.trim()).includes("bytes") === true;
-}
-async function cancelBody(response) {
-	await response.body?.cancel().catch(() => void 0);
-}
-async function preflightHttpUrl(url, fetchImpl, fetchInit, signal) {
-	const head = await fetchImpl(url, fetchInitFor(fetchInit, "HEAD", signal));
-	if (head.ok) {
-		const size = parseContentLength(head.headers);
-		if (size === null) throw new Error(`HEAD ${url} missing Content-Length`);
-		if (!supportsRangeReads(head.headers)) throw new Error(`HEAD ${url} missing Accept-Ranges: bytes`);
-		return size;
-	}
-	await cancelBody(head);
-	if (![
-		403,
-		405,
-		501
-	].includes(head.status)) throw new Error(`HEAD ${url} failed: ${head.status}`);
-	const probe = await fetchImpl(url, fetchInitFor(fetchInit, "GET", signal, { Range: "bytes=0-0" }));
-	try {
-		if (probe.status !== 206) throw new Error(`range probe ${url} failed: ${probe.status}`);
-		const size = parseContentRangeSize(probe.headers);
-		if (size === null) throw new Error(`range probe ${url} missing Content-Range size`);
-		return size;
-	} finally {
-		await cancelBody(probe);
-	}
-}
-function rangeOnlyConfig(config) {
-	return {
-		...config ?? {},
-		filesystem: {
-			reliableHeadRequests: true,
-			allowFullHTTPReads: false,
-			...config?.filesystem ?? {},
-			forceFullHTTPReads: false
-		}
-	};
-}
-async function dropAttachedResources(db, conn, schema, tables, files) {
-	for (const table of tables) await conn.query(`DROP VIEW IF EXISTS ${schema}.${table}`);
-	if (files.length > 0) await db.dropFiles([...files]);
-}
-function parseMemoryLimit(value) {
-	const trimmed = value.trim();
-	if (!/^\d+(?:\.\d+)?\s*(?:B|KB|MB|GB|TB)?$/i.test(trimmed)) throw new Error(`invalid memoryLimit '${value}' — expected e.g. '512MB' or '2GB'`);
-	return trimmed;
-}
-async function bootDuckDBWasm(options = {}) {
-	const { getJsDelivrBundles, selectBundle, AsyncDuckDB, ConsoleLogger, LogLevel } = await import("@duckdb/duckdb-wasm");
-	const bundle = await selectBundle(options.bundles ?? getJsDelivrBundles());
-	const workerUrl = URL.createObjectURL(new Blob([`importScripts("${bundle.mainWorker}");`], { type: "text/javascript" }));
-	const worker = new Worker(workerUrl);
-	const db = new AsyncDuckDB(options.logger ?? new ConsoleLogger(LogLevel.WARNING), worker);
-	try {
-		await db.instantiate(bundle.mainModule, bundle.pthreadWorker);
-		await db.open(rangeOnlyConfig(options.config));
-		const conn = await db.connect();
-		if (options.memoryLimit !== void 0) await conn.query(`SET memory_limit='${parseMemoryLimit(options.memoryLimit)}'`);
-		return {
-			db,
-			conn
-		};
-	} catch (err) {
-		worker.terminate();
-		throw err;
-	} finally {
-		URL.revokeObjectURL(workerUrl);
-	}
-}
-async function attachParquetTables(options) {
-	const { db, conn, tables, schema = "main" } = options;
-	for (const table of tables) {
-		const names = [];
-		for (let i = 0; i < table.files.length; i++) {
-			const file = table.files[i];
-			const name = fileName(table.table, i, file.name);
-			names.push(name);
-			await db.registerFileBuffer(name, file.bytes);
-		}
-		await conn.query(readParquetViewSql(schema, table.table, names));
-	}
-}
-async function attachParquetUrlTablesResult(options) {
-	const { db, conn, tables, fetch: fetchImpl = globalThis.fetch.bind(globalThis), schema = "main", fetchInit, fetchConcurrency, maxFiles, maxBytes, signal, version, onFileAttached, attachMode = "http", trustSizeHint = true } = options;
-	const concurrency = positiveInteger(fetchConcurrency, DEFAULT_ATTACH_FETCH_CONCURRENCY, "fetchConcurrency");
-	const fileBudget = positiveInteger(maxFiles, DEFAULT_ATTACH_MAX_FILES, "maxFiles");
-	const byteBudget = positiveInteger(maxBytes, DEFAULT_ATTACH_MAX_BYTES, "maxBytes");
-	const attachId = nextAttachId++;
-	const flat = [];
-	const counts = {};
-	for (const [table, urls] of tables.map((t) => [t.table, t.urls])) {
-		if (urls.length === 0) continue;
-		counts[table] = urls.length;
-		for (let i = 0; i < urls.length; i++) flat.push({
-			table,
-			url: urls[i],
-			index: i
-		});
-	}
-	if (flat.length > fileBudget) return err(browserAttachErrors.maxFilesExceeded(flat.length, fileBudget));
-	const hintedBytes = flat.reduce((acc, item) => {
-		const hint = sizeHintFromUrl(item.url);
-		return hint === null ? acc : acc + hint;
-	}, 0);
-	if (hintedBytes > byteBudget) return err(browserAttachErrors.hintedBytesExceeded(hintedBytes, byteBudget));
-	const tableFailures = /* @__PURE__ */ new Map();
-	const budgetController = new AbortController();
-	const effectiveSignal = mergeAbortSignals(signal, budgetController.signal);
-	let plannedBytes = 0;
-	const total = flat.length;
-	const prepared = [];
-	try {
-		await runWithConcurrency(flat, concurrency, async ({ table, url, index }) => {
-			if (tableFailures.has(table)) return;
-			effectiveSignal?.throwIfAborted();
-			try {
-				let bytes = null;
-				let body = null;
-				if (attachMode === "buffer") {
-					const res = await fetchImpl(url, fetchInitFor(fetchInit, "GET", effectiveSignal));
-					if (!res.ok) throw new Error(`GET ${url} failed: ${res.status}`);
-					const buf = new Uint8Array(await res.arrayBuffer());
-					body = buf;
-					bytes = buf.byteLength;
-				} else if (trustSizeHint && sizeHintFromUrl(url) !== null) bytes = sizeHintFromUrl(url);
-				else bytes = await preflightHttpUrl(url, fetchImpl, fetchInit, effectiveSignal);
-				plannedBytes += bytes;
-				if (plannedBytes > byteBudget) {
-					const budgetErr = new BrowserAttachBudgetExceededError(`browser parquet attach planned ${plannedBytes} bytes, above maxBytes=${byteBudget}`);
-					budgetController.abort(budgetErr);
-					throw budgetErr;
-				}
-				effectiveSignal?.throwIfAborted();
-				prepared.push({
-					table,
-					url,
-					index,
-					name: attachFileName(attachId, table, index),
-					bytes,
-					body
-				});
-			} catch (err) {
-				if (effectiveSignal?.aborted || err instanceof BrowserAttachBudgetExceededError || isAbortError(err)) throw err;
-				tableFailures.set(table, err instanceof Error ? err : new Error(String(err)));
-			}
-		});
-	} catch (downloadErr) {
-		if (downloadErr instanceof BrowserAttachBudgetExceededError && !signal?.aborted) return err(browserAttachErrors.plannedBytesExceeded(plannedBytes, byteBudget));
-		throw downloadErr;
-	}
-	const { DuckDBDataProtocol } = await import("@duckdb/duckdb-wasm");
-	const attached = [];
-	const registeredFiles = [];
-	try {
-		for (const file of prepared) {
-			if (tableFailures.has(file.table)) continue;
-			effectiveSignal?.throwIfAborted();
-			if (file.body !== null) await db.registerFileBuffer(file.name, file.body);
-			else await db.registerFileURL(file.name, file.url, DuckDBDataProtocol.HTTP, false);
-			registeredFiles.push(file.name);
-			onFileAttached?.({
-				table: file.table,
-				index: file.index,
-				total
-			});
-		}
-		for (const table of Object.keys(counts)) {
-			if (tableFailures.has(table)) continue;
-			const files = prepared.filter((file) => file.table === table).sort((a, b) => a.index - b.index);
-			if (files.length !== counts[table]) continue;
-			effectiveSignal?.throwIfAborted();
-			await conn.query(readParquetViewSql(schema, table, files.map((file) => file.name)));
-			attached.push(table);
-		}
-	} catch (err) {
-		await dropAttachedResources(db, conn, schema, attached, registeredFiles).catch((cleanupErr) => {
-			console.warn("[gscdump/engine-duckdb-wasm] cleanup after failed attach failed", cleanupErr);
-		});
-		throw err;
-	}
-	if (tableFailures.size > 0) for (const [table, err] of tableFailures) console.warn(`[gscdump/engine-duckdb-wasm] dropped table "${table}" — ${err.message}`);
-	let detached = false;
-	return ok({
-		version,
-		tables: attached,
-		schema,
-		async detach() {
-			if (detached) return;
-			detached = true;
-			await dropAttachedResources(db, conn, schema, attached, registeredFiles);
-		}
-	});
-}
-async function attachParquetUrlTables(options) {
-	return unwrapResult(await attachParquetUrlTablesResult(options), browserAttachErrorToException);
-}
-function createBrowserAnalysisRuntime(boot, options = {}) {
-	const { db, conn } = boot;
-	const schema = options.schema ?? "main";
-	let version = options.version;
-	let attachedTables = options.attachedTables;
-	let chain = Promise.resolve();
-	function abortError(signal) {
-		return signal.reason ?? new DOMException("aborted", "AbortError");
-	}
-	function raceSignal(promise, signal) {
-		if (!signal) return promise;
-		if (signal.aborted) return Promise.reject(abortError(signal));
-		return new Promise((resolve, reject) => {
-			const onAbort = () => reject(abortError(signal));
-			signal.addEventListener("abort", onAbort, { once: true });
-			promise.then((value) => {
-				signal.removeEventListener("abort", onAbort);
-				resolve(value);
-			}, (err) => {
-				signal.removeEventListener("abort", onAbort);
-				reject(err);
-			});
-		});
-	}
-	function runExclusive(signal, work) {
-		const next = chain.then(work, work);
-		chain = next.then(() => void 0, () => void 0);
-		return raceSignal(next, signal);
-	}
-	async function cancelOnAbort(signal, work) {
-		if (!signal) return work;
-		if (signal.aborted) throw abortError(signal);
-		const onAbort = () => {
-			conn.cancelSent().catch((error) => {
-				console.warn("[gscdump/engine-duckdb-wasm] failed to cancel aborted query", error);
-			});
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-		try {
-			return await work;
-		} finally {
-			signal.removeEventListener("abort", onAbort);
-		}
-	}
-	async function runParameterizedDirect(sql, params, signal) {
-		signal?.throwIfAborted();
-		return cancelOnAbort(signal, (async () => {
-			if (!params || params.length === 0) return conn.query(sql);
-			const stmt = await conn.prepare(sql);
-			try {
-				return await stmt.query(...params);
-			} finally {
-				await stmt.close();
-			}
-		})());
-	}
-	return {
-		db,
-		conn,
-		async query(sql, params, signal) {
-			const t0 = performance.now();
-			return {
-				rows: arrowToRows(await runExclusive(signal, () => runParameterizedDirect(sql, params, signal))),
-				queryMs: performance.now() - t0
-			};
-		},
-		async analyze(params, registry, options = {}) {
-			const signal = options.signal;
-			const run = async () => {
-				signal?.throwIfAborted();
-				const t0 = performance.now();
-				const result = await runAnalyzerFromSource(createAttachedTableSource({ query: async (sql, bindParams, innerSignal) => {
-					return arrowToRows(await runParameterizedDirect(sql, bindParams, innerSignal ?? signal));
-				} }, {
-					schema,
-					signal,
-					attachedTables,
-					adapter: pgResolverAdapter
-				}), params, registry);
-				return {
-					results: result.results,
-					meta: result.meta,
-					queryMs: performance.now() - t0
-				};
-			};
-			return runExclusive(signal, run);
-		},
-		isStale(expected) {
-			return expected !== version;
-		},
-		setVersion(next) {
-			version = next;
-		},
-		setAttachedTables(next) {
-			attachedTables = next;
-		},
-		async close() {
-			await conn.close();
-			await db.terminate();
-		}
-	};
-}
 export { BrowserAttachBudgetExceededError, DuckDBWasmDatabase, OpfsQuotaExceededError, attachOpfsParquetTables, attachParquetTables, attachParquetUrlTables, attachParquetUrlTablesResult, bootDuckDBWasm, browserAttachErrors, clearOpfsSnapshotCache, compileArchetypeSql, countries, createBrowserAnalysisRuntime, createClient, createInsightRunner, dates, drizzle, estimateOpfsStorage, hourly_pages, isBrowserAttachError, mergeScope, overlayViewBody, page_queries, pages, queries, readOpfsSnapshotFile, requestPersistentStorage, resolveWindow, schema, scopeFor, tableForArchetype };