@gscdump/engine-duckdb-wasm 0.25.13 → 0.26.0

package/dist/index.d.mts

@@ -4,6 +4,7 @@ import { AnyRelations, EmptyRelations, ExtractTablesWithRelations, Schema as Sch
 import { DrizzleSchema as Schema, countries, dates, drizzleSchema as schema, hourly_pages, page_queries, pages, queries } from "@gscdump/engine/schema";
 import { ScopedRunnerOptions, TableScope } from "@gscdump/engine/scope";
 import { AnalyzerRegistry } from "@gscdump/engine/analyzer";
+import { Result } from "gscdump/result";
 import { ComparisonMode, ResolveWindowOptions, ResolvedWindow, WindowPreset, resolveWindow } from "@gscdump/engine/period";
 import { ArchetypeQuery } from "@gscdump/sdk";
 import { AsyncDuckDB, AsyncDuckDBConnection, DuckDBBundles, DuckDBConfig } from "@duckdb/duckdb-wasm";
@@ -217,6 +218,14 @@ interface DuckDBWasmBootResult {
   conn: AsyncDuckDBConnection;
 }
 interface BootDuckDBWasmOptions {
+  /**
+   * DuckDB-WASM logger. Defaults to a `ConsoleLogger` thresholded at
+   * `LogLevel.WARNING`, so real warnings/errors still surface but the per-query
+   * INFO events (START/OK/RUN) — which DuckDB's default `ConsoleLogger()` emits
+   * as raw objects, flooding the host console with dozens of lines per render —
+   * are dropped. Pass `new ConsoleLogger(LogLevel.DEBUG)` to see everything, or
+   * `new VoidLogger()` to silence it entirely.
+   */
   logger?: unknown;
   /**
    * Override the jsDelivr-hosted bundle map. Required in environments where
@@ -354,12 +363,40 @@ interface BrowserAnalysisRuntime {
 declare class BrowserAttachBudgetExceededError extends Error {
   name: string;
 }
+interface BrowserAttachError {
+  kind: 'browser-attach-budget-exceeded';
+  message: string;
+  /** Which budget tripped: the file count, the hinted byte plan, or the running byte plan. */
+  budget: 'maxFiles' | 'maxBytes';
+}
+declare const browserAttachErrors: {
+  readonly maxFilesExceeded: (files: number, maxFiles: number) => BrowserAttachError;
+  readonly hintedBytesExceeded: (hintedBytes: number, maxBytes: number) => BrowserAttachError;
+  readonly plannedBytesExceeded: (plannedBytes: number, maxBytes: number) => BrowserAttachError;
+};
+declare function isBrowserAttachError(value: unknown): value is BrowserAttachError;
 declare function bootDuckDBWasm(options?: BootDuckDBWasmOptions): Promise<DuckDBWasmBootResult>;
 declare function attachParquetTables(options: AttachParquetTablesOptions): Promise<void>;
+/**
+ * Errors-as-values core for {@link attachParquetUrlTables}: returns a typed
+ * {@link BrowserAttachError} when the requested file set blows the local file-
+ * count / byte budget, so callers can branch (route the affected tables
+ * server-side) instead of catching an untyped throw. WASM/DuckDB/HTTP IO
+ * failures stay defects and propagate. `attachParquetUrlTables` is the thin
+ * throwing wrapper preserving the historical `BrowserAttachBudgetExceededError`.
+ */
+declare function attachParquetUrlTablesResult(options: AttachParquetUrlTablesOptions): Promise<Result<AttachedTablesHandle, BrowserAttachError>>;
+/**
+ * Attach browser parquet URL tables, throwing
+ * {@link BrowserAttachBudgetExceededError} when the requested set blows the
+ * file-count / byte budget. Thin throwing wrapper over
+ * {@link attachParquetUrlTablesResult}; existing call sites and their
+ * `instanceof BrowserAttachBudgetExceededError` checks keep holding.
+ */
 declare function attachParquetUrlTables(options: AttachParquetUrlTablesOptions): Promise<AttachedTablesHandle>;
 declare function createBrowserAnalysisRuntime(boot: DuckDBWasmBootResult, options?: {
   schema?: string;
   version?: number | string;
   attachedTables?: readonly string[];
 }): BrowserAnalysisRuntime;
-export { type AnalyzeResult, type AttachOpfsTablesOptions, type AttachParquetTablesOptions, type AttachParquetUrlTablesOptions, type AttachedTablesHandle, type BootDuckDBWasmOptions, type BrowserAnalysisRuntime, BrowserAttachBudgetExceededError, type BrowserParquetFile, type BrowserParquetTable, type BrowserParquetUrlTable, type ComparisonMode, type CompiledArchetypeSql, type DuckDBWasmBootResult, type DuckDBWasmClient, DuckDBWasmDatabase, type DuckDBWasmDrizzleDatabase, type InsightRunner, type InsightRunnerOptions, type OpfsAttachedHandle, type OpfsFileProgress, type OpfsParquetFile, type OpfsParquetTable, OpfsQuotaExceededError, type QueryResult, type ResolveWindowOptions, type ResolvedWindow, type Schema, type ScopedRunnerOptions, type StrikingMomentumOptions, type StrikingMomentumRow, type TableScope, type WindowPreset, attachOpfsParquetTables, attachParquetTables, attachParquetUrlTables, bootDuckDBWasm, clearOpfsSnapshotCache, compileArchetypeSql, countries, createBrowserAnalysisRuntime, createClient, createInsightRunner, dates, drizzle, estimateOpfsStorage, hourly_pages, mergeScope, page_queries, pages, queries, requestPersistentStorage, resolveWindow, schema, scopeFor, strikingMomentum, tableForArchetype };
+export { type AnalyzeResult, type AttachOpfsTablesOptions, type AttachParquetTablesOptions, type AttachParquetUrlTablesOptions, type AttachedTablesHandle, type BootDuckDBWasmOptions, type BrowserAnalysisRuntime, BrowserAttachBudgetExceededError, type BrowserAttachError, type BrowserParquetFile, type BrowserParquetTable, type BrowserParquetUrlTable, type ComparisonMode, type CompiledArchetypeSql, type DuckDBWasmBootResult, type DuckDBWasmClient, DuckDBWasmDatabase, type DuckDBWasmDrizzleDatabase, type InsightRunner, type InsightRunnerOptions, type OpfsAttachedHandle, type OpfsFileProgress, type OpfsParquetFile, type OpfsParquetTable, OpfsQuotaExceededError, type QueryResult, type ResolveWindowOptions, type ResolvedWindow, type Schema, type ScopedRunnerOptions, type StrikingMomentumOptions, type StrikingMomentumRow, type TableScope, type WindowPreset, attachOpfsParquetTables, attachParquetTables, attachParquetUrlTables, attachParquetUrlTablesResult, bootDuckDBWasm, browserAttachErrors, clearOpfsSnapshotCache, compileArchetypeSql, countries, createBrowserAnalysisRuntime, createClient, createInsightRunner, dates, drizzle, estimateOpfsStorage, hourly_pages, isBrowserAttachError, mergeScope, page_queries, pages, queries, requestPersistentStorage, resolveWindow, schema, scopeFor, strikingMomentum, tableForArchetype };

package/dist/index.mjs

@@ -9,6 +9,7 @@ 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 { resolveWindow } from "@gscdump/engine/period";
 const METRIC_SQL = {
 	clicks: "SUM(clicks)",
@@ -166,7 +167,8 @@ function compileArchetypeSql(query) {
 			}
 			const col = DIM_COLUMN[query.dimension];
 			const facet = facetPredicate(query);
-			let sql = `SELECT ${col} AS ${query.dimension}, ${metricSelectList(query.metrics)} FROM ${table} WHERE ${where.sql}${facet.sql} GROUP BY ${col} ORDER BY ${query.orderBy.metric} ${dir} LIMIT ?`;
+			const totalCol = query.includeTotal ? ", COUNT(*) OVER() AS __total" : "";
+			let sql = `SELECT ${col} AS ${query.dimension}, ${metricSelectList(query.metrics)}${totalCol} FROM ${table} WHERE ${where.sql}${facet.sql} GROUP BY ${col} ORDER BY ${query.orderBy.metric} ${dir} LIMIT ?`;
 			const params = [
 				...where.params,
 				...facet.params,
@@ -277,7 +279,7 @@ async function createClient(db, conn) {
 			try {
 				return arrowToRows(await stmt.query(...params));
 			} finally {
-				stmt.close();
+				await stmt.close();
 			}
 		},
 		async close() {
@@ -489,12 +491,27 @@ function isOpfsAccessHandleConflict(err) {
 	const msg = err instanceof Error ? err.message : String(err);
 	return /createSyncAccessHandle|Access Handle/i.test(msg);
 }
-function opfsFileName(table, index, hashSlug) {
-	const base = `${OPFS_PREFIX}${table}_${index}`;
-	return hashSlug ? `${base}_${hashSlug}.parquet` : `${base}.parquet`;
+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$`);
 }
-function opfsFileNamePrefix(table, index) {
-	return `${OPFS_PREFIX}${table}_${index}`;
+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;
+		await root.removeEntry(name).catch(() => {});
+	}
 }
 async function requestPersistentStorage() {
 	const storage = globalThis.navigator?.storage;
@@ -523,7 +540,7 @@ async function getOpfsRoot() {
 	if (!dir) throw new Error("[engine-duckdb-wasm/opfs] OPFS unavailable: navigator.storage.getDirectory missing");
 	return dir.call(globalThis.navigator.storage);
 }
-async function materialiseFile(root, name, staleSweepPrefix, file, fetchImpl, fetchInit, signal) {
+async function materialiseFile(root, name, file, fetchImpl, fetchInit, signal) {
 	signal?.throwIfAborted();
 	let handle;
 	try {
@@ -533,12 +550,6 @@ async function materialiseFile(root, name, staleSweepPrefix, file, fetchImpl, fe
 			outcome: "cache-hit"
 		};
 	} catch {}
-	const dir = root;
-	if (dir.keys) for await (const existing of dir.keys()) {
-		if (existing === name || !existing.startsWith(staleSweepPrefix) || !existing.endsWith(".parquet")) continue;
-		const next = existing.charAt(staleSweepPrefix.length);
-		if (next === "." || next === "_") await root.removeEntry(existing).catch(() => {});
-	}
 	signal?.throwIfAborted();
 	const resp = await fetchImpl(file.url, {
 		...fetchInit,
@@ -573,7 +584,7 @@ function readParquetViewSql$1(schema, table, 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)`;
 	if (lakeFiles.length === 0) return `CREATE OR REPLACE VIEW ${schema}.${table} AS ${overlay}`;
-	return `CREATE OR REPLACE VIEW ${schema}.${table} AS ${lakeSelect(lakeFiles)} UNION ALL BY NAME ${overlay} WHERE CAST(date AS DATE) NOT IN (SELECT DISTINCT CAST(date AS DATE) FROM read_parquet([${quoteList(lakeFiles)}], union_by_name = true))`;
+	return `CREATE OR REPLACE VIEW ${schema}.${table} AS WITH lake AS MATERIALIZED (${lakeSelect(lakeFiles)}), lake_dates AS (SELECT DISTINCT date FROM lake) SELECT * FROM lake UNION ALL BY NAME SELECT * FROM (${overlay}) AS overlay WHERE overlay.date NOT IN (SELECT date FROM lake_dates)`;
 }
 async function runWithConcurrency$1(items, concurrency, fn) {
 	let next = 0;
@@ -596,24 +607,39 @@ async function attachOpfsParquetTables(options) {
 	await requestPersistentStorage();
 	const root = await getOpfsRoot();
 	const flat = [];
+	const expectedByTable = /* @__PURE__ */ new Map();
 	for (const t of tables) {
-		for (let i = 0; i < t.files.length; i++) flat.push({
-			table: t.table,
-			file: t.files[i],
-			fileIndex: i
-		});
-		if (t.overlay) flat.push({
-			table: t.table,
-			file: t.overlay,
-			fileIndex: t.files.length,
-			overlay: true
-		});
+		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 import("@duckdb/duckdb-wasm");
 	const registry = getOpfsRegistry(db, DuckDBDataProtocol.BROWSER_FSACCESS);
+	await sweepStaleEntries(root, registry, expectedByTable).catch(() => {});
 	const tableFiles = /* @__PURE__ */ new Map();
 	const degraded = /* @__PURE__ */ new Set();
 	const acquiredNames = /* @__PURE__ */ new Set();
@@ -626,12 +652,10 @@ async function attachOpfsParquetTables(options) {
 	const runDownloads = () => runWithConcurrency$1(flat, Math.max(1, fetchConcurrency), async (item, index) => {
 		if (degraded.has(item.table)) return;
 		signal?.throwIfAborted();
-		const hashSlug = item.file.contentHash ? await contentHashSlug(item.file.contentHash) : void 0;
-		const name = opfsFileName(item.table, item.fileIndex, hashSlug);
-		const sweepPrefix = opfsFileNamePrefix(item.table, item.fileIndex);
+		const name = item.name;
 		let result;
 		try {
-			result = await materialiseFile(root, name, sweepPrefix, item.file, fetchImpl, fetchInit, signal);
+			result = await materialiseFile(root, name, item.file, fetchImpl, fetchInit, signal);
 		} catch (err) {
 			if (isAbortError$1(err)) throw err;
 			if (isQuotaError(err)) {
@@ -758,6 +782,37 @@ 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`;
 }
@@ -886,11 +941,11 @@ async function dropAttachedResources(db, conn, schema, tables, files) {
 	if (files.length > 0) await db.dropFiles([...files]);
 }
 async function bootDuckDBWasm(options = {}) {
-	const { getJsDelivrBundles, selectBundle, AsyncDuckDB, ConsoleLogger } = await import("@duckdb/duckdb-wasm");
+	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(), worker);
+	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));
@@ -918,7 +973,7 @@ async function attachParquetTables(options) {
 		await conn.query(readParquetViewSql(schema, table.table, names));
 	}
 }
-async function attachParquetUrlTables(options) {
+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");
@@ -935,52 +990,57 @@ async function attachParquetUrlTables(options) {
 			index: i
 		});
 	}
-	if (flat.length > fileBudget) throw new BrowserAttachBudgetExceededError(`browser parquet attach requires ${flat.length} files, above maxFiles=${fileBudget}`);
+	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) throw new BrowserAttachBudgetExceededError(`browser parquet attach requires ${hintedBytes} hinted bytes, above maxBytes=${byteBudget}`);
+	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 = [];
-	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 err = new BrowserAttachBudgetExceededError(`browser parquet attach planned ${plannedBytes} bytes, above maxBytes=${byteBudget}`);
-				budgetController.abort(err);
-				throw err;
-			}
+	try {
+		await runWithConcurrency(flat, concurrency, async ({ table, url, index }) => {
+			if (tableFailures.has(table)) return;
 			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)));
-		}
-	});
+			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 = [];
@@ -1013,7 +1073,7 @@ async function attachParquetUrlTables(options) {
 	}
 	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 {
+	return ok({
 		version,
 		tables: attached,
 		schema,
@@ -1022,7 +1082,10 @@ async function attachParquetUrlTables(options) {
 			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;
@@ -1124,4 +1187,4 @@ function createBrowserAnalysisRuntime(boot, options = {}) {
 		}
 	};
 }
-export { BrowserAttachBudgetExceededError, DuckDBWasmDatabase, OpfsQuotaExceededError, attachOpfsParquetTables, attachParquetTables, attachParquetUrlTables, bootDuckDBWasm, clearOpfsSnapshotCache, compileArchetypeSql, countries, createBrowserAnalysisRuntime, createClient, createInsightRunner, dates, drizzle, estimateOpfsStorage, hourly_pages, mergeScope, page_queries, pages, queries, requestPersistentStorage, resolveWindow, schema, scopeFor, strikingMomentum, tableForArchetype };
+export { BrowserAttachBudgetExceededError, DuckDBWasmDatabase, OpfsQuotaExceededError, attachOpfsParquetTables, attachParquetTables, attachParquetUrlTables, attachParquetUrlTablesResult, bootDuckDBWasm, browserAttachErrors, clearOpfsSnapshotCache, compileArchetypeSql, countries, createBrowserAnalysisRuntime, createClient, createInsightRunner, dates, drizzle, estimateOpfsStorage, hourly_pages, isBrowserAttachError, mergeScope, page_queries, pages, queries, requestPersistentStorage, resolveWindow, schema, scopeFor, strikingMomentum, tableForArchetype };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/engine-duckdb-wasm",
   "type": "module",
-  "version": "0.25.13",
+  "version": "0.26.0",
   "description": "DuckDB-WASM engine adapter for @gscdump/analysis — typed browser analytics against parquet via R2.",
   "author": {
     "name": "Harlan Wilton",
@@ -45,16 +45,16 @@
   },
   "dependencies": {
     "drizzle-orm": "1.0.0-rc.3",
-    "@gscdump/engine": "0.25.13",
-    "gscdump": "0.25.13",
-    "@gscdump/sdk": "0.25.13"
+    "@gscdump/engine": "0.26.0",
+    "@gscdump/sdk": "0.26.0",
+    "gscdump": "0.26.0"
   },
   "devDependencies": {
     "@duckdb/duckdb-wasm": "^1.32.0",
-    "@vitest/browser": "^4.1.7",
-    "@vitest/browser-playwright": "^4.1.7",
+    "@vitest/browser": "^4.1.8",
+    "@vitest/browser-playwright": "^4.1.8",
     "playwright": "^1.60.0",
-    "vitest": "^4.1.7"
+    "vitest": "^4.1.8"
   },
   "scripts": {
     "build": "obuild",