@gscdump/engine 0.38.2 → 0.40.1

package/README.md

@@ -37,21 +37,20 @@ Optional peers (install only what your runtime needs):
 | `@gscdump/engine/scope` | Multi-tenant scope predicates. |
 | `@gscdump/engine/arrow` | Apache Arrow utilities for engine result conversion. |
 | `@gscdump/engine/node` | Node-only DuckDB handle. |
-| `@gscdump/engine/node-harness` | Node test harness for engine integration tests. |
 | `@gscdump/engine/filesystem` | Node-only `DataSource` + `ManifestStore` adapters. |
-| `@gscdump/engine/http` | Read-only HTTP `DataSource` (signed URLs, Range requests). |
 | `@gscdump/engine/hyparquet` | Pure-JS `ParquetCodec`. |
 | `@gscdump/engine/r2` | Cloudflare R2 `DataSource` (structurally typed against `R2Bucket`). |
 | `@gscdump/engine/r2-manifest` | R2-backed `ManifestStore` for hosted deployments. |
-| `@gscdump/engine/inspection-sqlite-node` | Node SQLite adapter for URL-inspection cache. |
-| `@gscdump/engine/inspection-sqlite-browser` | Browser (wa-sqlite) adapter for URL-inspection cache. |
+| `@gscdump/engine/iceberg` | Edge-safe GSC Iceberg schema/catalog/append sink. |
+| `@gscdump/engine/sink-node` | Node-only Iceberg overwrite/delete recovery writer. |
+| `@gscdump/engine/source` | Query-source contracts and factories. |
 
 ## Stability
 
 | Surface | Stability |
 |---|---|
 | `createStorageEngine` and storage contracts (`StorageEngine`, `Row`, `WriteCtx`, ...) | Public |
-| Adapters (`/node`, `/filesystem`, `/http`, `/hyparquet`, `/r2`) | Public |
+| Adapters (`/node`, `/filesystem`, `/hyparquet`, `/r2`, `/r2-manifest`) | Public |
 | Planner (`resolveToSQL`, `enumeratePartitions`) | Public |
 | Schema (`SCHEMAS`, `allTables`, ...) | Public |
 | Internals reached through `@gscdump/engine/<file>` paths not listed above | Private — may break between minors |
@@ -60,7 +59,6 @@ Optional peers (install only what your runtime needs):
 
 - [`gscdump`](../gscdump) — REST client + query builder (edge-safe peer dep).
 - [`@gscdump/analysis`](../analysis) — analyzers; consumes `StorageEngine` via `createEngine` factories.
-- [`@gscdump/engine-duckdb-node`](../engine-duckdb-node) — Node DuckDB analyzer adapter.
 - [`@gscdump/engine-duckdb-wasm`](../engine-duckdb-wasm) — DuckDB-WASM browser adapter.
 - [`@gscdump/engine-sqlite`](../engine-sqlite) — SQLite / D1 adapter.
 - [`@gscdump/cli`](../cli) — CLI wrapping engine + analysis.

package/dist/_chunks/compaction.mjs

@@ -189,42 +189,46 @@ function splitOverlappingTiers(entries, queryRange) {
 	const spanned = [];
 	const kept = [];
 	const subsumed = [];
+	const clampToRange = Number.isFinite(rangeStartMs) && Number.isFinite(rangeEndMs);
 	for (const entry of entries) {
 		const span = partitionSpan(entry.partition);
 		if (!span) {
 			kept.push(entry);
 			continue;
 		}
-		const days = [];
-		for (let t = span.startMs; t <= span.endMs; t += MS_PER_DAY) {
-			if (rangeStartMs !== void 0 && (t < rangeStartMs || t > rangeEndMs)) continue;
-			days.push(t);
-		}
-		if (queryRange && days.length === 0) {
+		const startMs = clampToRange ? Math.max(span.startMs, rangeStartMs) : span.startMs;
+		const endMs = clampToRange ? Math.min(span.endMs, rangeEndMs) : span.endMs;
+		if (queryRange && startMs > endMs) {
 			subsumed.push(entry);
 			continue;
 		}
 		spanned.push({
 			entry,
 			rank: span.rank,
-			days
+			startMs,
+			endMs
 		});
 	}
 	spanned.sort((a, b) => a.rank - b.rank || b.entry.createdAt - a.entry.createdAt);
 	const coveredBySearchType = /* @__PURE__ */ new Map();
-	for (const { entry, days } of spanned) {
+	for (const { entry, startMs, endMs } of spanned) {
 		const slice = inferSearchType(entry);
 		let covered = coveredBySearchType.get(slice);
 		if (!covered) {
 			covered = /* @__PURE__ */ new Set();
 			coveredBySearchType.set(slice, covered);
 		}
-		if (days.every((d) => covered.has(d))) {
+		let fullyCovered = true;
+		for (let dayMs = startMs; dayMs <= endMs; dayMs += MS_PER_DAY) if (!covered.has(dayMs)) {
+			fullyCovered = false;
+			break;
+		}
+		if (fullyCovered) {
 			subsumed.push(entry);
 			continue;
 		}
 		kept.push(entry);
-		for (const d of days) covered.add(d);
+		for (let dayMs = startMs; dayMs <= endMs; dayMs += MS_PER_DAY) covered.add(dayMs);
 	}
 	return {
 		kept,

package/dist/_chunks/duckdb.d.mts

@@ -14,8 +14,16 @@ interface DuckDBHandle {
 interface DuckDBFactory {
   getDuckDB: () => Promise<DuckDBHandle>;
 }
-declare function createDuckDBCodec(factory: DuckDBFactory): ParquetCodec;
-declare function createDuckDBExecutor(factory: DuckDBFactory): QueryExecutor;
+interface DuckDBReadOptions {
+  /**
+   * Maximum non-URI parquet reads held in flight while registering DuckDB
+   * buffers. Defaults to 16; callers handling unusually large files can lower
+   * it to trade latency for peak JS memory.
+   */
+  bufferReadConcurrency?: number;
+}
+declare function createDuckDBCodec(factory: DuckDBFactory, options?: DuckDBReadOptions): ParquetCodec;
+declare function createDuckDBExecutor(factory: DuckDBFactory, options?: DuckDBReadOptions): QueryExecutor;
 /**
  * Canonical "empty-file" SELECT clause for a table. Codecs that need to
  * emit a schema-correct empty Parquet can wrap this in:

package/dist/_chunks/engine.mjs

@@ -8,11 +8,16 @@ import { sqlEscape } from "../sql-bind.mjs";
 import { encodeJsonBigintSafe } from "@gscdump/lakehouse";
 import { buildLogicalPlan } from "gscdump/query/plan";
 import { normalizeUrl } from "gscdump/normalize";
-const BUFFER_READ_BATCH_SIZE = 8;
-async function registerBufferedFiles(db, files, dataSource, registered, signal) {
-	for (let i = 0; i < files.length; i += BUFFER_READ_BATCH_SIZE) {
+const DEFAULT_BUFFER_READ_CONCURRENCY = 16;
+const MAX_BUFFER_READ_CONCURRENCY = 64;
+function bufferReadConcurrency(value, fileCount) {
+	return Math.max(1, Math.min(fileCount || 1, typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : DEFAULT_BUFFER_READ_CONCURRENCY, MAX_BUFFER_READ_CONCURRENCY));
+}
+async function registerBufferedFiles(db, files, dataSource, registered, signal, maxConcurrency) {
+	const batchSize = bufferReadConcurrency(maxConcurrency, files.length);
+	for (let i = 0; i < files.length; i += batchSize) {
 		signal?.throwIfAborted();
-		const batch = files.slice(i, i + BUFFER_READ_BATCH_SIZE);
+		const batch = files.slice(i, i + batchSize);
 		const buffers = await Promise.all(batch.map((file) => dataSource.read(file.key, void 0, signal)));
 		for (let j = 0; j < batch.length; j++) {
 			signal?.throwIfAborted();
@@ -47,7 +52,7 @@ async function decodeBytes(db, bytes, table) {
 		await db.dropFiles([name]);
 	}
 }
-function createDuckDBCodec(factory) {
+function createDuckDBCodec(factory, options = {}) {
 	return {
 		async writeRows(ctx, rows, key, dataSource) {
 			const bytes = await encodeBytes(await factory.getDuckDB(), ctx.table, rows);
@@ -100,7 +105,7 @@ function createDuckDBCodec(factory) {
 				};
 			});
 			try {
-				await registerBufferedFiles(db, bufferedInputs, dataSource, registered);
+				await registerBufferedFiles(db, bufferedInputs, dataSource, registered, void 0, options.bufferReadConcurrency);
 				const fileList = inNames.map((n) => `'${sqlEscape(n)}'`).join(", ");
 				await db.query(`COPY (${dedupedMergeSql(ctx.table, fileList)}) TO '${sqlEscape(outName)}' (FORMAT PARQUET, COMPRESSION ZSTD)`);
 				registered.push(outName);
@@ -137,7 +142,7 @@ function rewriteEmptyFileSets(sql, placeholders, defaultTable, placeholderTables
 	}
 	return out;
 }
-function createDuckDBExecutor(factory) {
+function createDuckDBExecutor(factory, options = {}) {
 	return { async execute({ sql, params, fileKeys, placeholderTables, dataSource, table, signal, profiler }) {
 		signal?.throwIfAborted();
 		const db = await factory.getDuckDB();
@@ -146,24 +151,24 @@ function createDuckDBExecutor(factory) {
 		const totalFiles = Object.values(fileKeys).reduce((n, keys) => n + keys.length, 0);
 		const endRegister = profiler?.start("files.register", { files: totalFiles });
 		try {
-			await Promise.all(Object.entries(fileKeys).map(async ([name, keys]) => {
+			const bufferedByName = /* @__PURE__ */ new Map();
+			for (const [name, keys] of Object.entries(fileKeys)) {
 				const resolved = [];
-				const buffered = [];
 				for (let i = 0; i < keys.length; i++) {
 					const key = keys[i];
 					const uri = dataSource.uri?.(key);
 					if (uri !== void 0) resolved.push(uri);
 					else {
-						buffered.push({
+						if (!bufferedByName.has(key)) bufferedByName.set(key, {
 							key,
 							name: key
 						});
 						resolved.push(key);
 					}
 				}
-				await registerBufferedFiles(db, buffered, dataSource, registered, signal);
 				placeholders[name] = resolved;
-			}));
+			}
+			await registerBufferedFiles(db, [...bufferedByName.values()], dataSource, registered, signal, options.bufferReadConcurrency);
 			endRegister?.({ buffered: registered.length });
 			signal?.throwIfAborted();
 			const finalSql = substituteNamedFiles(rewriteEmptyFileSets(sql, placeholders, table, placeholderTables), placeholders);

package/dist/_chunks/entities.mjs

@@ -9,9 +9,6 @@ function isMissingKeyError(e) {
 	return /\bnot found\b|\bENOENT\b|\bmissing key\b/i.test(message);
 }
 async function readOptional(ds, key, signal) {
-	if (ds.head) {
-		if (await ds.head(key) === void 0) return void 0;
-	}
 	return await ds.read(key, void 0, signal).catch((e) => {
 		if (isMissingKeyError(e)) return void 0;
 		throw e;
@@ -72,9 +69,6 @@ function buildQueryDimRecords(queries, deps) {
 	return out;
 }
 function createQueryDimStore({ dataSource }) {
-	async function exists(key, prefix) {
-		return (await dataSource.list(prefix)).includes(key);
-	}
 	return {
 		parquetKey: queryDimParquetKey,
 		async write(ctx, records, builtAt) {
@@ -98,15 +92,14 @@ function createQueryDimStore({ dataSource }) {
 			};
 		},
 		async loadMeta(ctx) {
-			const key = queryDimMetaKey(ctx);
-			if (!await exists(key, `${queryDimPrefix(ctx)}/`)) return null;
-			const bytes = await dataSource.read(key);
+			const bytes = await readOptional(dataSource, queryDimMetaKey(ctx));
+			if (!bytes) return null;
 			return JSON.parse(new TextDecoder().decode(bytes));
 		},
 		async loadRecords(ctx) {
-			const key = queryDimParquetKey(ctx);
-			if (!await exists(key, `${queryDimPrefix(ctx)}/`)) return [];
-			return (await decodeParquetToRows(await dataSource.read(key))).map((r) => ({
+			const bytes = await readOptional(dataSource, queryDimParquetKey(ctx));
+			if (!bytes) return [];
+			return (await decodeParquetToRows(bytes)).map((r) => ({
 				query: String(r.query),
 				query_canonical: String(r.query_canonical),
 				intent_code: Number(r.intent_code),
@@ -117,6 +110,21 @@ function createQueryDimStore({ dataSource }) {
 	};
 }
 const YEAR_MONTH_RE = /^(\d{4})-(\d{2})-/;
+const ENTITY_IO_CONCURRENCY = 8;
+async function mapEntityIo(items, fn) {
+	if (items.length === 0) return [];
+	const results = Array.from({ length: items.length }, () => void 0);
+	let next = 0;
+	async function worker() {
+		while (true) {
+			const index = next++;
+			if (index >= items.length) return;
+			results[index] = await fn(items[index], index);
+		}
+	}
+	await Promise.all(Array.from({ length: Math.min(ENTITY_IO_CONCURRENCY, items.length) }, worker));
+	return results;
+}
 function inspectionIndexKey(ctx) {
 	return ctx.siteId ? `u_${ctx.userId}/${ctx.siteId}/entities/inspections/index.json` : `u_${ctx.userId}/entities/inspections/index.json`;
 }
@@ -311,33 +319,33 @@ function createInspectionStore(opts) {
 				if (!byMonth.has(month)) byMonth.set(month, []);
 				byMonth.get(month).push(r);
 			}
-			for (const [yearMonth, batch] of byMonth) {
+			await mapEntityIo([...byMonth].map(([yearMonth, batch]) => {
 				const bytes = encodeJsonBigintSafe({
 					version: 1,
 					records: batch
 				});
 				if (bytes.byteLength > 5242880) throw new Error(`inspection history shard exceeds ${INSPECTION_HISTORY_MAX_BYTES} bytes (got ${bytes.byteLength}); split the batch`);
-				await ds.write(inspectionHistoryShardKey(ctx, yearMonth, batchId), bytes);
-			}
+				return {
+					key: inspectionHistoryShardKey(ctx, yearMonth, batchId),
+					bytes
+				};
+			}), (shard) => ds.write(shard.key, shard.bytes));
 		},
 		async loadHistory(ctx, yearMonth) {
 			const keys = await ds.list(inspectionHistoryPrefix(ctx, yearMonth));
 			if (keys.length === 0) return void 0;
-			const out = [];
-			for (const key of keys) {
-				const bytes = await readOptional(ds, key);
-				if (!bytes) continue;
-				const shard = await Promise.resolve().then(() => JSON.parse(new TextDecoder().decode(bytes))).catch((err) => {
-					console.warn("[inspection.loadHistory] failed to decode shard", {
-						key,
-						error: err.message
-					});
-				});
-				if (shard?.records) out.push(...shard.records);
-			}
 			return {
 				version: 1,
-				records: out
+				records: (await mapEntityIo(keys, async (key) => {
+					const bytes = await readOptional(ds, key);
+					if (!bytes) return [];
+					return (await Promise.resolve().then(() => JSON.parse(new TextDecoder().decode(bytes))).catch((err) => {
+						console.warn("[inspection.loadHistory] failed to decode shard", {
+							key,
+							error: err.message
+						});
+					}))?.records ?? [];
+				})).flat()
 			};
 		},
 		async materialize(ctx, rowIter) {
@@ -369,18 +377,19 @@ function createInspectionStore(opts) {
 				bucket.push(r);
 				byMonth.set(month, bucket);
 			}
-			const keys = [];
-			for (const [month, batch] of byMonth) {
+			const files = [...byMonth].map(([month, batch]) => {
 				const bytes = encodeRowsToParquetFlex(batch, {
 					columns: INSPECTION_EVENT_COLUMNS,
 					sortKey: ["urlHash"]
 				});
-				const key = inspectionEventKey(ctx, month, batchId);
-				await ds.write(key, bytes);
-				keys.push(key);
-			}
+				return {
+					key: inspectionEventKey(ctx, month, batchId),
+					bytes
+				};
+			});
+			await mapEntityIo(files, (file) => ds.write(file.key, file.bytes));
 			return {
-				keys,
+				keys: files.map((file) => file.key),
 				rowCount: rows.length
 			};
 		},
@@ -410,11 +419,18 @@ function createInspectionStore(opts) {
 			for (const row of baseRows) consider(row);
 			let eventsFolded = 0;
 			const consumed = [];
-			for (const key of eventKeys.sort()) {
+			const eventFiles = await mapEntityIo(eventKeys.sort(), async (key) => {
 				const bytes = await readOptional(ds, key);
-				if (!bytes) continue;
+				if (!bytes) return void 0;
+				return {
+					key,
+					rows: await decodeParquetToRows(bytes)
+				};
+			});
+			for (const file of eventFiles) {
+				if (!file) continue;
+				const { key, rows } = file;
 				consumed.push(key);
-				const rows = await decodeParquetToRows(bytes);
 				for (const row of rows) {
 					consider(row);
 					eventsFolded++;
@@ -610,16 +626,18 @@ function createSitemapStore(opts) {
 				records: {}
 			};
 			const stamp = now();
+			const historyDocs = /* @__PURE__ */ new Map();
 			for (const r of records) {
 				const h = hash(r.path);
 				index.records[h] = r;
-				await writeJson(sitemapHistoryKey(ctx, h, stamp), {
+				historyDocs.set(sitemapHistoryKey(ctx, h, stamp), {
 					version: 1,
 					path: r.path,
 					capturedAt: r.capturedAt,
 					record: r
 				});
 			}
+			await mapEntityIo([...historyDocs], ([key, doc]) => writeJson(key, doc));
 			await writeJson(indexKey, index);
 		},
 		async loadIndex(ctx) {
@@ -702,9 +720,10 @@ function createSitemapStore(opts) {
 		async *loadUrls(ctx, feedpath, opts) {
 			const fpHash = hash(feedpath);
 			const includeRemoved = opts?.includeRemoved ?? false;
-			const indexBytes = await readOptional(ds, sitemapUrlsIndexKey(ctx, fpHash));
-			const indexRows = indexBytes ? await decodeParquetToRows(indexBytes) : [];
-			const deltaKeys = (await ds.list(`${sitemapUrlsPrefix(ctx)}/deltas/`)).sort();
+			const [indexRows, listedDeltaKeys] = await Promise.all([readOptional(ds, sitemapUrlsIndexKey(ctx, fpHash)).then((bytes) => bytes ? decodeParquetToRows(bytes) : []), ds.list(`${sitemapUrlsPrefix(ctx)}/deltas/`)]);
+			const deltaKeys = listedDeltaKeys.filter((key) => {
+				return SITEMAP_URLS_DELTA_PREFIX_RE.exec(key)?.[2] === fpHash;
+			}).sort();
 			const live = /* @__PURE__ */ new Map();
 			const removedMap = /* @__PURE__ */ new Map();
 			for (const row of indexRows) {
@@ -712,36 +731,34 @@ function createSitemapStore(opts) {
 				if (rec.removedAt != null) removedMap.set(rec.urlHash, rec);
 				else live.set(rec.urlHash, rec);
 			}
-			for (const key of deltaKeys) {
-				const m = SITEMAP_URLS_DELTA_PREFIX_RE.exec(key);
-				if (!m || m[2] !== fpHash) continue;
+			const deltas = await mapEntityIo(deltaKeys, async (key) => {
 				const dBytes = await readOptional(ds, key);
-				if (!dBytes) continue;
-				const dRows = await decodeParquetToRows(dBytes);
-				for (const r of dRows) {
-					const op = String(r.op);
-					const urlHash = String(r.url_hash);
-					const at = Number(r.at);
-					if (op === "added") {
-						const prev = live.get(urlHash) ?? removedMap.get(urlHash);
-						removedMap.delete(urlHash);
-						live.set(urlHash, {
-							feedpath,
-							feedpathHash: fpHash,
-							urlHash,
-							loc: String(r.loc),
-							lastmod: r.lastmod == null ? void 0 : String(r.lastmod),
-							firstSeenAt: prev?.firstSeenAt ?? at,
-							lastSeenAt: at
-						});
-					} else if (op === "removed") {
-						const prev = live.get(urlHash);
-						live.delete(urlHash);
-						if (prev) removedMap.set(urlHash, {
-							...prev,
-							removedAt: at
-						});
-					}
+				if (!dBytes) return [];
+				return decodeParquetToRows(dBytes);
+			});
+			for (const dRows of deltas) for (const r of dRows) {
+				const op = String(r.op);
+				const urlHash = String(r.url_hash);
+				const at = Number(r.at);
+				if (op === "added") {
+					const prev = live.get(urlHash) ?? removedMap.get(urlHash);
+					removedMap.delete(urlHash);
+					live.set(urlHash, {
+						feedpath,
+						feedpathHash: fpHash,
+						urlHash,
+						loc: String(r.loc),
+						lastmod: r.lastmod == null ? void 0 : String(r.lastmod),
+						firstSeenAt: prev?.firstSeenAt ?? at,
+						lastSeenAt: at
+					});
+				} else if (op === "removed") {
+					const prev = live.get(urlHash);
+					live.delete(urlHash);
+					if (prev) removedMap.set(urlHash, {
+						...prev,
+						removedAt: at
+					});
 				}
 			}
 			for (const rec of live.values()) yield rec;
@@ -796,8 +813,14 @@ function createSitemapStore(opts) {
 			for (const [fpHash, feedDeltaKeys] of deltasByFeed) {
 				if (compactedFeedpaths > 0 && (compactedFeedpaths >= maxFeedpaths || now() - startedAt >= deadlineMs)) break;
 				const indexKey = sitemapUrlsIndexKey(ctx, fpHash);
-				const indexBytes = await readOptional(ds, indexKey);
-				const indexRows = indexBytes ? await decodeParquetToRows(indexBytes) : [];
+				const [indexRows, deltaFiles] = await Promise.all([readOptional(ds, indexKey).then((bytes) => bytes ? decodeParquetToRows(bytes) : []), mapEntityIo(feedDeltaKeys.sort(), async (key) => {
+					const bytes = await readOptional(ds, key);
+					if (!bytes) return void 0;
+					return {
+						key,
+						rows: await decodeParquetToRows(bytes)
+					};
+				})]);
 				const live = /* @__PURE__ */ new Map();
 				const removed = /* @__PURE__ */ new Map();
 				for (const row of indexRows) {
@@ -806,11 +829,10 @@ function createSitemapStore(opts) {
 					else live.set(rec.urlHash, rec);
 				}
 				const consumed = [];
-				for (const key of feedDeltaKeys.sort()) {
-					const bytes = await readOptional(ds, key);
-					if (!bytes) continue;
+				for (const file of deltaFiles) {
+					if (!file) continue;
+					const { key, rows } = file;
 					consumed.push(key);
-					const rows = await decodeParquetToRows(bytes);
 					for (const r of rows) {
 						const urlHash = String(r.url_hash);
 						const at = Number(r.at);
@@ -856,12 +878,13 @@ function createSitemapStore(opts) {
 			const at = atOpt ?? now();
 			const liveHashes = new Set(liveFeedpaths.map((fp) => hash(fp)));
 			const present = /* @__PURE__ */ new Set();
-			for (const key of await ds.list(`${sitemapUrlsIndexPrefix(ctx)}/`)) {
+			const [indexKeys, deltaKeys] = await Promise.all([ds.list(`${sitemapUrlsIndexPrefix(ctx)}/`), ds.list(`${sitemapUrlsPrefix(ctx)}/deltas/`)]);
+			for (const key of indexKeys) {
 				const m = /\/by-feed\/([0-9a-f]+)\/index\.parquet$/.exec(key);
 				if (m) present.add(m[1]);
 			}
 			const deltasByFeed = /* @__PURE__ */ new Map();
-			for (const key of await ds.list(`${sitemapUrlsPrefix(ctx)}/deltas/`)) {
+			for (const key of deltaKeys) {
 				const m = SITEMAP_URLS_DELTA_PREFIX_RE.exec(key);
 				if (!m) continue;
 				present.add(m[2]);
@@ -874,8 +897,14 @@ function createSitemapStore(opts) {
 			for (const fpHash of present) {
 				if (liveHashes.has(fpHash)) continue;
 				const indexKey = sitemapUrlsIndexKey(ctx, fpHash);
-				const indexBytes = await readOptional(ds, indexKey);
-				const indexRows = indexBytes ? await decodeParquetToRows(indexBytes) : [];
+				const [indexRows, deltaFiles] = await Promise.all([readOptional(ds, indexKey).then((bytes) => bytes ? decodeParquetToRows(bytes) : []), mapEntityIo((deltasByFeed.get(fpHash) ?? []).sort(), async (key) => {
+					const bytes = await readOptional(ds, key);
+					if (!bytes) return void 0;
+					return {
+						key,
+						rows: await decodeParquetToRows(bytes)
+					};
+				})]);
 				const live = /* @__PURE__ */ new Map();
 				const removed = /* @__PURE__ */ new Map();
 				for (const row of indexRows) {
@@ -884,11 +913,10 @@ function createSitemapStore(opts) {
 					else live.set(r.urlHash, r);
 				}
 				const consumed = [];
-				for (const key of (deltasByFeed.get(fpHash) ?? []).sort()) {
-					const bytes = await readOptional(ds, key);
-					if (!bytes) continue;
+				for (const file of deltaFiles) {
+					if (!file) continue;
+					const { key, rows } = file;
 					consumed.push(key);
-					const rows = await decodeParquetToRows(bytes);
 					for (const r of rows) {
 						const urlHash = String(r.url_hash);
 						const dat = Number(r.at);

package/dist/_chunks/errors.d.mts

@@ -103,8 +103,6 @@ declare const engineErrors: {
   readonly lockAcquireTimeout: (scope: string, timeoutMs: number) => EngineError;
 };
 declare function isEngineError(value: unknown): value is EngineError;
-/** The human-readable rendering of an `EngineError`, for logs and string sinks. */
-declare function formatEngineError(error: EngineError): string;
 /**
  * Re-raises an `EngineError` value as a generic `Error`, stashing the union under
  * `.engineError` for stack-walking. Used by the throwing wrappers over the
@@ -114,4 +112,4 @@ declare function formatEngineError(error: EngineError): string;
  * mapper so the class identity callers match on is preserved.
  */
 declare function engineErrorToException(error: EngineError): Error;
-export { EngineError, EngineErrorKind, engineErrorToException, engineErrors, formatEngineError, isEngineError };
+export { EngineError, EngineErrorKind, engineErrorToException, engineErrors, isEngineError };

package/dist/_chunks/index.d.mts

@@ -105,14 +105,5 @@ declare function createEngineQuerySource(options: EngineQuerySourceOptions): Ana
 declare function runAnalyzerWithEngine(deps: {
   engine: StorageEngine;
 }, ctx: TenantCtx, params: AnalysisParams, registry: AnalyzerRegistry): Promise<AnalysisResult>;
-interface TypedQuery<TRow> {
-  state: BuilderState;
-  readonly __row?: TRow;
-}
-declare function typedQuery<TRow>(state: BuilderState): TypedQuery<TRow>;
-declare function queryRows<TRow = QueryRow>(source: AnalysisQuerySource, query: BuilderState | TypedQuery<TRow>): Promise<TRow[]>;
-declare function queryComparisonRows<TRow = QueryRow>(source: AnalysisQuerySource, current: BuilderState | TypedQuery<TRow>, previous: BuilderState | TypedQuery<TRow>): Promise<{
-  current: TRow[];
-  previous: TRow[];
-}>;
-export { AttachedTableMissingError, AttachedTableRunner, AttachedTableSourceOptions, CreateSqlQuerySourceOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, TypedQuery, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery };
+declare function queryRows<TRow = QueryRow>(source: AnalysisQuerySource, state: BuilderState): Promise<TRow[]>;
+export { AttachedTableMissingError, AttachedTableRunner, AttachedTableSourceOptions, CreateSqlQuerySourceOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryRows, rewriteForTableSource, runAnalyzerWithEngine };

package/dist/_chunks/index2.d.mts

@@ -30,9 +30,6 @@ declare function defaultStartDate(): string;
 declare function periodOf(params: AnalysisParams): AnalysisPeriod;
 declare function comparisonOf(params: AnalysisParams): ComparisonPeriod;
 declare function resolveWindow(opts: ResolveWindowOptions): ResolvedWindow;
-/** Convert a ResolvedWindow into the AnalysisPeriod / ComparisonPeriod shape. */
-declare function windowToPeriod(w: ResolvedWindow): AnalysisPeriod;
-declare function windowToComparisonPeriod(w: ResolvedWindow): ComparisonPeriod | undefined;
 interface PadTimeseriesOptions<T> {
   /** ISO date (YYYY-MM-DD), inclusive lower bound. */
   startDate: string;
@@ -54,4 +51,4 @@ type DateRowShape = Record<string, unknown> & {
  * once. Existing dates keep all their rows (grouped timeseries safe).
  */
 declare function padTimeseries<T extends DateRowShape = DateRowShape>(rows: readonly T[], options: PadTimeseriesOptions<T>): T[];
-export { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow, windowToComparisonPeriod, windowToPeriod };
+export { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow };

package/dist/_chunks/pg-adapter.d.mts

@@ -14,12 +14,6 @@ declare const pgResolverAdapter: ResolverAdapter<PgTableKey>;
  * accidental adapter caching that would lock in a stale `{{FILES}}` set.
  */
 interface ResolverAdapterOptions {
-  /**
-   * Deprecated compatibility flag. Fact tables no longer carry
-   * `query_canonical`; canonical reads derive from `query_dim`, or from a
-   * canonical rollup relation when `queryCanonicalSource: 'column'` is set.
-   */
-  canonicalFallback?: boolean;
   /**
    * `queryDim` reads canonical from a joined query dimension. `column` is only
    * for derived canonical rollup relations whose primary relation already