@gscdump/engine 0.6.1 → 0.6.3

package/dist/_chunks/types.d.mts

@@ -0,0 +1,53 @@
+import { LogicalDataset, PlannerCapabilities } from "gscdump/query/plan";
+import { SQL } from "drizzle-orm";
+import { Dimension, InternalFilter, Metric } from "gscdump/query";
+interface ResolverAdapter<TableKey extends string = string> {
+  readonly METRIC_NAMES: readonly Metric[];
+  readonly capabilities: PlannerCapabilities;
+  readonly schema: Record<TableKey, unknown>;
+  tableKeyForDataset: (dataset: LogicalDataset) => TableKey;
+  inferTable: (dimensions: Dimension[], filterDims?: Dimension[]) => TableKey;
+  dimColumn: (dim: Dimension, tableKey: TableKey) => string;
+  isMetricDimension: (dim: string) => dim is Metric;
+  tableRef: (tableKey: TableKey) => SQL;
+  dateColRef: (tableKey: TableKey) => SQL;
+  urlToPathExpr: (col: string) => string;
+  siteIdColRef?: (tableKey: TableKey) => SQL;
+  dimExprSql: (dim: Dimension, tableKey: TableKey) => SQL;
+  metricSql: (metric: Metric, tableKey: TableKey) => SQL;
+  dimensionPredicates: (filters: InternalFilter[], tableKey: TableKey) => SQL[];
+  havingPredicates: (filters: InternalFilter[], tableKey: TableKey) => SQL[];
+  topLevelPredicate: (filters: InternalFilter[], tableKey: TableKey) => SQL | undefined;
+  compile: (query: SQL) => {
+    sql: string;
+    params: unknown[];
+  };
+}
+type ComparisonFilter = 'new' | 'lost' | 'improving' | 'declining';
+interface ResolverOptions<TableKey extends string = string> {
+  adapter: ResolverAdapter<TableKey>;
+  /** Optional site scope. Required for multi-tenant D1; omitted for parquet. */
+  siteId?: string | number;
+}
+interface ResolvedSQL {
+  sql: string;
+  params: unknown[];
+  countSql: string;
+  countParams: unknown[];
+}
+interface ResolvedSQLOptimized {
+  sql: string;
+  params: unknown[];
+}
+interface ResolvedComparisonSQL {
+  sql: string;
+  params: unknown[];
+  countSql: string;
+  countParams: unknown[];
+}
+interface ExtraQuery {
+  key: string;
+  sql: string;
+  params: unknown[];
+}
+export { ResolvedSQLOptimized as a, ResolvedSQL as i, ExtraQuery as n, ResolverAdapter as o, ResolvedComparisonSQL as r, ResolverOptions as s, ComparisonFilter as t };

package/dist/adapters/duckdb-node.d.mts

@@ -1,16 +1,4 @@
-import { Row } from "gscdump/contracts";
-interface DuckDBHandle {
-  query: (sql: string, params?: unknown[]) => Promise<Row[]>;
-  registerFileBuffer: (name: string, bytes: Uint8Array) => Promise<void>;
-  copyFileToBuffer: (name: string) => Promise<Uint8Array>;
-  dropFiles: (names: string[]) => Promise<void>;
-  /**
-   * Returns a unique path suitable for `COPY TO '…'` + `copyFileToBuffer`.
-   * In Node this is an absolute path under `os.tmpdir()` so DuckDB doesn't
-   * litter the CWD; in browsers/Workers it's a plain virtual-FS name.
-   */
-  makeTempPath: (ext: string) => string;
-}
+import { n as DuckDBHandle } from "../_chunks/duckdb.mjs";
 interface NodeDuckDBOptions {
   verbose?: boolean;
 }

package/dist/adapters/duckdb-node.mjs

@@ -1,3 +1,4 @@
+import { arrowToRows } from "../arrow-utils.mjs";
 import { createRequire } from "node:module";
 import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -5,13 +6,6 @@ import { join } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { ConsoleLogger, NODE_RUNTIME, VoidLogger, createDuckDB } from "@duckdb/duckdb-wasm/dist/duckdb-node-blocking.cjs";
-function arrowToRows(result) {
-	const r = result;
-	const arr = Array.isArray(r) ? r : typeof r?.toArray === "function" ? r.toArray() : [];
-	if (!arr || arr.length === 0) return [];
-	if (typeof arr[0]?.toJSON === "function") return arr.map((r) => r.toJSON());
-	return arr;
-}
 const require_ = createRequire(typeof __filename !== "undefined" ? __filename : typeof import.meta !== "undefined" ? fileURLToPath(import.meta.url) : process.cwd());
 let singleton = null;
 function bundles() {

package/dist/adapters/filesystem.d.mts

@@ -1,196 +1,4 @@
-import { TableName } from "gscdump/contracts";
-import { SearchType } from "gscdump/query";
-/**
- * Compaction tier of a manifest entry. Determines which compactor stage may
- * pick it up as input:
- * - `raw`: per-day file produced by `writeDay`. Eligible for raw→d7 merge at 7d.
- * - `d7`: weekly compaction output. Eligible for d7→d30 merge at 30d.
- * - `d30`: monthly compaction output (matches the legacy `monthly/` partition
- *   shape — pre-tier entries are read as `d30`). Eligible for d30→d90 at 90d.
- * - `d90`: quarterly cold-tier output. Terminal; never recompacted.
- *
- * Without an explicit tier, entries written before this field landed default
- * to `raw` for `daily/` partitions and `d30` for `monthly/` partitions, so
- * the tiered compactor picks the right inputs without a backfill rewrite.
- */
-type CompactionTier = 'raw' | 'd7' | 'd30' | 'd90';
-interface ManifestEntry {
-  userId: string;
-  siteId?: string;
-  table: TableName;
-  partition: string;
-  objectKey: string;
-  rowCount: number;
-  bytes: number;
-  createdAt: number;
-  retiredAt?: number;
-  /** Table schema version at write time. Omitted on pre-#27 entries — treat as 1. */
-  schemaVersion?: number;
-  /**
-   * Compaction tier. Omitted on entries written before tiered compaction —
-   * treat as `raw` for `daily/` partitions and `d30` for `monthly/` partitions
-   * (see {@link inferLegacyTier}).
-   */
-  tier?: CompactionTier;
-  /**
-   * GSC search-type this entry covers (web | discover | news | googleNews |
-   * image | video). Omitted on entries written before per-type partitioning
-   * landed — treat as `web` (see {@link inferSearchType}). Compaction merges
-   * only entries with the same searchType.
-   */
-  searchType?: SearchType;
-}
-interface ListLiveFilter {
-  userId: string;
-  siteId?: string;
-  table?: TableName;
-  partitions?: string[];
-  /**
-   * Narrow to a single compaction tier. Tier-aware compaction stages set this
-   * so the store doesn't have to return (and the caller doesn't have to scan)
-   * the entire manifest just to compact the raw cohort. Legacy entries without
-   * an explicit `tier` field match on {@link inferLegacyTier}.
-   */
-  tier?: CompactionTier;
-}
-interface DataSource {
-  read: (key: string, range?: {
-    offset: number;
-    length: number;
-  }, signal?: AbortSignal) => Promise<Uint8Array>;
-  write: (key: string, bytes: Uint8Array) => Promise<void>;
-  delete: (keys: string[]) => Promise<void>;
-  /**
-   * One-shot listing under a prefix. Implementations may cap the number of
-   * returned keys (typically 10k) — callers iterating full tenant space
-   * should prefer `streamList` when available or narrow the prefix.
-   */
-  list: (prefix: string) => Promise<string[]>;
-  /**
-   * Per-key URI probe. Returns a URI string DuckDB's `httpfs` (or an
-   * equivalent engine that fetches its own I/O) can read directly, or
-   * `undefined` if the key isn't URI-resolvable on this backend and the
-   * caller must fall back to `read(key)` for the bytes.
-   *
-   * Contracts:
-   * - When defined, the returned URI MUST yield byte-identical content to
-   *   `read(key)`. Callers rely on this for correctness.
-   * - Backends with a native URI for every key (filesystem: absolute path,
-   *   R2 via `httpfs`: signed URL) may always return a string.
-   * - Backends without a native URI shape (in-memory) omit the method or
-   *   return `undefined` per call.
-   * - Mixed-per-query is allowed: some keys in one query may return a URI,
-   *   others may not; the executor branches per key.
-   */
-  uri?: (key: string) => string | undefined;
-  /**
-   * Optional — probe the byte size of a key without reading it. Used by
-   * the engine to fill in `WriteResult.bytes` when a codec reports 0 or
-   * unknown but the file is non-trivial.
-   */
-  head?: (key: string) => Promise<{
-    bytes: number;
-  } | undefined>;
-  /**
-   * Optional streaming variant of `list`. Implementations that page
-   * backing-store results (R2, S3) should implement this and yield keys
-   * lazily. `list` may return up to an adapter-defined cap (typically
-   * 10k keys); callers iterating full tenant space must prefer
-   * `streamList` when available, or chunk by narrower prefixes.
-   */
-  streamList?: (prefix: string) => AsyncIterable<string>;
-}
-interface WatermarkScope {
-  userId: string;
-  siteId?: string;
-  table: TableName;
-}
-interface Watermark extends WatermarkScope {
-  newestDateSynced: string;
-  oldestDateSynced: string;
-  lastSyncAt: number;
-}
-interface WatermarkFilter {
-  userId: string;
-  siteId?: string;
-  table?: TableName;
-}
-type SyncStateKind = 'pending' | 'inflight' | 'done' | 'failed';
-interface SyncStateScope {
-  userId: string;
-  siteId?: string;
-  table: TableName;
-  date: string;
-  /**
-   * GSC search-type this sync state covers. Omitted = `web` (the legacy
-   * default; matches pre-#5 sync states stored before per-type sync landed).
-   * Lookups must compare via {@link inferSearchType} so a missing field
-   * matches an explicit `'web'` and vice versa.
-   */
-  searchType?: SearchType;
-}
-interface SyncState extends SyncStateScope {
-  state: SyncStateKind;
-  updatedAt: number;
-  attempts: number;
-  error?: string;
-}
-interface SyncStateFilter {
-  userId: string;
-  siteId?: string;
-  table?: TableName;
-  state?: SyncStateKind;
-  searchType?: SearchType;
-}
-interface SyncStateDetail {
-  at?: number;
-  error?: string;
-}
-interface LockScope {
-  userId: string;
-  siteId?: string;
-  table: TableName;
-  partition: string;
-}
-interface PurgeFilter {
-  userId: string;
-  siteId?: string;
-}
-interface ManifestPurgeResult {
-  entriesRemoved: number;
-  watermarksRemoved: number;
-  syncStatesRemoved: number;
-}
-interface ManifestStore {
-  listLive: (filter: ListLiveFilter) => Promise<ManifestEntry[]>;
-  listAll: (filter: ListLiveFilter) => Promise<ManifestEntry[]>;
-  registerVersion: (entry: ManifestEntry, superseding?: ManifestEntry[]) => Promise<void>;
-  registerVersions: (entries: ManifestEntry[], superseding?: ManifestEntry[]) => Promise<void>;
-  listRetired: (olderThan: number) => Promise<ManifestEntry[]>;
-  delete: (entries: ManifestEntry[]) => Promise<void>;
-  getWatermarks: (filter: WatermarkFilter) => Promise<Watermark[]>;
-  bumpWatermark: (scope: WatermarkScope, date: string, at?: number) => Promise<void>;
-  getSyncStates: (filter: SyncStateFilter) => Promise<SyncState[]>;
-  setSyncState: (scope: SyncStateScope, state: SyncStateKind, detail?: SyncStateDetail) => Promise<void>;
-  /**
-   * Serialize concurrent writers against the same scope. Held across the
-   * write+register window so GC (orphan sweep) won't delete bytes that are
-   * midway between `dataSource.write` and `manifestStore.registerVersion`.
-   * Scope = tenant × table × partition.
-   */
-  withLock: <T>(scope: LockScope, fn: () => Promise<T>) => Promise<T>;
-  /**
-   * GDPR-grade tenant purge. Removes every manifest entry, watermark, and
-   * sync-state record matching the filter. Does NOT touch the underlying
-   * data-source bytes; callers (typically {@link StorageEngine.purgeTenant})
-   * must sweep the tenant prefix separately before invoking this so that
-   * mid-flight failures can't leave orphan parquet with no manifest record.
-   *
-   * On stores with CAS-backed sharding (R2 manifest) this may issue one
-   * mutation per shard. On read-only stores (HTTP) this throws.
-   */
-  purgeTenant: (filter: PurgeFilter) => Promise<ManifestPurgeResult>;
-}
+import { a as DataSource, m as ManifestStore } from "../_chunks/storage.mjs";
 interface FilesystemDataSourceOptions {
   rootDir: string;
 }

package/dist/adapters/filesystem.mjs

@@ -1,16 +1,9 @@
+import { i as inferSearchType, r as inferLegacyTier } from "../_chunks/storage.mjs";
+import { dirname, join, resolve } from "node:path";
 import { Buffer } from "node:buffer";
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
 import { lock } from "proper-lockfile";
-function inferSearchType(entry) {
-	return entry.searchType ?? "web";
-}
-function inferLegacyTier(entry) {
-	if (entry.tier !== void 0) return entry.tier;
-	if (entry.partition.startsWith("daily/")) return "raw";
-	if (entry.partition.startsWith("monthly/")) return "d30";
-}
 function createFilesystemDataSource(opts) {
 	const root = resolve(opts.rootDir);
 	function pathFor(key) {

package/dist/adapters/http.d.mts

@@ -1,196 +1,4 @@
-import { TableName } from "gscdump/contracts";
-import { SearchType } from "gscdump/query";
-/**
- * Compaction tier of a manifest entry. Determines which compactor stage may
- * pick it up as input:
- * - `raw`: per-day file produced by `writeDay`. Eligible for raw→d7 merge at 7d.
- * - `d7`: weekly compaction output. Eligible for d7→d30 merge at 30d.
- * - `d30`: monthly compaction output (matches the legacy `monthly/` partition
- *   shape — pre-tier entries are read as `d30`). Eligible for d30→d90 at 90d.
- * - `d90`: quarterly cold-tier output. Terminal; never recompacted.
- *
- * Without an explicit tier, entries written before this field landed default
- * to `raw` for `daily/` partitions and `d30` for `monthly/` partitions, so
- * the tiered compactor picks the right inputs without a backfill rewrite.
- */
-type CompactionTier = 'raw' | 'd7' | 'd30' | 'd90';
-interface ManifestEntry {
-  userId: string;
-  siteId?: string;
-  table: TableName;
-  partition: string;
-  objectKey: string;
-  rowCount: number;
-  bytes: number;
-  createdAt: number;
-  retiredAt?: number;
-  /** Table schema version at write time. Omitted on pre-#27 entries — treat as 1. */
-  schemaVersion?: number;
-  /**
-   * Compaction tier. Omitted on entries written before tiered compaction —
-   * treat as `raw` for `daily/` partitions and `d30` for `monthly/` partitions
-   * (see {@link inferLegacyTier}).
-   */
-  tier?: CompactionTier;
-  /**
-   * GSC search-type this entry covers (web | discover | news | googleNews |
-   * image | video). Omitted on entries written before per-type partitioning
-   * landed — treat as `web` (see {@link inferSearchType}). Compaction merges
-   * only entries with the same searchType.
-   */
-  searchType?: SearchType;
-}
-interface ListLiveFilter {
-  userId: string;
-  siteId?: string;
-  table?: TableName;
-  partitions?: string[];
-  /**
-   * Narrow to a single compaction tier. Tier-aware compaction stages set this
-   * so the store doesn't have to return (and the caller doesn't have to scan)
-   * the entire manifest just to compact the raw cohort. Legacy entries without
-   * an explicit `tier` field match on {@link inferLegacyTier}.
-   */
-  tier?: CompactionTier;
-}
-interface DataSource {
-  read: (key: string, range?: {
-    offset: number;
-    length: number;
-  }, signal?: AbortSignal) => Promise<Uint8Array>;
-  write: (key: string, bytes: Uint8Array) => Promise<void>;
-  delete: (keys: string[]) => Promise<void>;
-  /**
-   * One-shot listing under a prefix. Implementations may cap the number of
-   * returned keys (typically 10k) — callers iterating full tenant space
-   * should prefer `streamList` when available or narrow the prefix.
-   */
-  list: (prefix: string) => Promise<string[]>;
-  /**
-   * Per-key URI probe. Returns a URI string DuckDB's `httpfs` (or an
-   * equivalent engine that fetches its own I/O) can read directly, or
-   * `undefined` if the key isn't URI-resolvable on this backend and the
-   * caller must fall back to `read(key)` for the bytes.
-   *
-   * Contracts:
-   * - When defined, the returned URI MUST yield byte-identical content to
-   *   `read(key)`. Callers rely on this for correctness.
-   * - Backends with a native URI for every key (filesystem: absolute path,
-   *   R2 via `httpfs`: signed URL) may always return a string.
-   * - Backends without a native URI shape (in-memory) omit the method or
-   *   return `undefined` per call.
-   * - Mixed-per-query is allowed: some keys in one query may return a URI,
-   *   others may not; the executor branches per key.
-   */
-  uri?: (key: string) => string | undefined;
-  /**
-   * Optional — probe the byte size of a key without reading it. Used by
-   * the engine to fill in `WriteResult.bytes` when a codec reports 0 or
-   * unknown but the file is non-trivial.
-   */
-  head?: (key: string) => Promise<{
-    bytes: number;
-  } | undefined>;
-  /**
-   * Optional streaming variant of `list`. Implementations that page
-   * backing-store results (R2, S3) should implement this and yield keys
-   * lazily. `list` may return up to an adapter-defined cap (typically
-   * 10k keys); callers iterating full tenant space must prefer
-   * `streamList` when available, or chunk by narrower prefixes.
-   */
-  streamList?: (prefix: string) => AsyncIterable<string>;
-}
-interface WatermarkScope {
-  userId: string;
-  siteId?: string;
-  table: TableName;
-}
-interface Watermark extends WatermarkScope {
-  newestDateSynced: string;
-  oldestDateSynced: string;
-  lastSyncAt: number;
-}
-interface WatermarkFilter {
-  userId: string;
-  siteId?: string;
-  table?: TableName;
-}
-type SyncStateKind = 'pending' | 'inflight' | 'done' | 'failed';
-interface SyncStateScope {
-  userId: string;
-  siteId?: string;
-  table: TableName;
-  date: string;
-  /**
-   * GSC search-type this sync state covers. Omitted = `web` (the legacy
-   * default; matches pre-#5 sync states stored before per-type sync landed).
-   * Lookups must compare via {@link inferSearchType} so a missing field
-   * matches an explicit `'web'` and vice versa.
-   */
-  searchType?: SearchType;
-}
-interface SyncState extends SyncStateScope {
-  state: SyncStateKind;
-  updatedAt: number;
-  attempts: number;
-  error?: string;
-}
-interface SyncStateFilter {
-  userId: string;
-  siteId?: string;
-  table?: TableName;
-  state?: SyncStateKind;
-  searchType?: SearchType;
-}
-interface SyncStateDetail {
-  at?: number;
-  error?: string;
-}
-interface LockScope {
-  userId: string;
-  siteId?: string;
-  table: TableName;
-  partition: string;
-}
-interface PurgeFilter {
-  userId: string;
-  siteId?: string;
-}
-interface ManifestPurgeResult {
-  entriesRemoved: number;
-  watermarksRemoved: number;
-  syncStatesRemoved: number;
-}
-interface ManifestStore {
-  listLive: (filter: ListLiveFilter) => Promise<ManifestEntry[]>;
-  listAll: (filter: ListLiveFilter) => Promise<ManifestEntry[]>;
-  registerVersion: (entry: ManifestEntry, superseding?: ManifestEntry[]) => Promise<void>;
-  registerVersions: (entries: ManifestEntry[], superseding?: ManifestEntry[]) => Promise<void>;
-  listRetired: (olderThan: number) => Promise<ManifestEntry[]>;
-  delete: (entries: ManifestEntry[]) => Promise<void>;
-  getWatermarks: (filter: WatermarkFilter) => Promise<Watermark[]>;
-  bumpWatermark: (scope: WatermarkScope, date: string, at?: number) => Promise<void>;
-  getSyncStates: (filter: SyncStateFilter) => Promise<SyncState[]>;
-  setSyncState: (scope: SyncStateScope, state: SyncStateKind, detail?: SyncStateDetail) => Promise<void>;
-  /**
-   * Serialize concurrent writers against the same scope. Held across the
-   * write+register window so GC (orphan sweep) won't delete bytes that are
-   * midway between `dataSource.write` and `manifestStore.registerVersion`.
-   * Scope = tenant × table × partition.
-   */
-  withLock: <T>(scope: LockScope, fn: () => Promise<T>) => Promise<T>;
-  /**
-   * GDPR-grade tenant purge. Removes every manifest entry, watermark, and
-   * sync-state record matching the filter. Does NOT touch the underlying
-   * data-source bytes; callers (typically {@link StorageEngine.purgeTenant})
-   * must sweep the tenant prefix separately before invoking this so that
-   * mid-flight failures can't leave orphan parquet with no manifest record.
-   *
-   * On stores with CAS-backed sharding (R2 manifest) this may issue one
-   * mutation per shard. On read-only stores (HTTP) this throws.
-   */
-  purgeTenant: (filter: PurgeFilter) => Promise<ManifestPurgeResult>;
-}
+import { a as DataSource, m as ManifestStore } from "../_chunks/storage.mjs";
 interface HttpDataSourceOptions {
   /**
    * Base URL to prefix each object key with. MUST NOT have a trailing slash.

package/dist/adapters/http.mjs

@@ -1,8 +1,4 @@
-function inferLegacyTier(entry) {
-	if (entry.tier !== void 0) return entry.tier;
-	if (entry.partition.startsWith("daily/")) return "raw";
-	if (entry.partition.startsWith("monthly/")) return "d30";
-}
+import { r as inferLegacyTier } from "../_chunks/storage.mjs";
 function readOnly(name) {
 	throw new Error(`http adapter is read-only: ${name} is not supported`);
 }

package/dist/adapters/hyparquet.d.mts

@@ -1,83 +1,6 @@
-import { ColumnDef, Row, Row as Row$1, TableName, TableName as TableName$1 } from "gscdump/contracts";
-interface DataSource {
-  read: (key: string, range?: {
-    offset: number;
-    length: number;
-  }, signal?: AbortSignal) => Promise<Uint8Array>;
-  write: (key: string, bytes: Uint8Array) => Promise<void>;
-  delete: (keys: string[]) => Promise<void>;
-  /**
-   * One-shot listing under a prefix. Implementations may cap the number of
-   * returned keys (typically 10k) — callers iterating full tenant space
-   * should prefer `streamList` when available or narrow the prefix.
-   */
-  list: (prefix: string) => Promise<string[]>;
-  /**
-   * Per-key URI probe. Returns a URI string DuckDB's `httpfs` (or an
-   * equivalent engine that fetches its own I/O) can read directly, or
-   * `undefined` if the key isn't URI-resolvable on this backend and the
-   * caller must fall back to `read(key)` for the bytes.
-   *
-   * Contracts:
-   * - When defined, the returned URI MUST yield byte-identical content to
-   *   `read(key)`. Callers rely on this for correctness.
-   * - Backends with a native URI for every key (filesystem: absolute path,
-   *   R2 via `httpfs`: signed URL) may always return a string.
-   * - Backends without a native URI shape (in-memory) omit the method or
-   *   return `undefined` per call.
-   * - Mixed-per-query is allowed: some keys in one query may return a URI,
-   *   others may not; the executor branches per key.
-   */
-  uri?: (key: string) => string | undefined;
-  /**
-   * Optional — probe the byte size of a key without reading it. Used by
-   * the engine to fill in `WriteResult.bytes` when a codec reports 0 or
-   * unknown but the file is non-trivial.
-   */
-  head?: (key: string) => Promise<{
-    bytes: number;
-  } | undefined>;
-  /**
-   * Optional streaming variant of `list`. Implementations that page
-   * backing-store results (R2, S3) should implement this and yield keys
-   * lazily. `list` may return up to an adapter-defined cap (typically
-   * 10k keys); callers iterating full tenant space must prefer
-   * `streamList` when available, or chunk by narrower prefixes.
-   */
-  streamList?: (prefix: string) => AsyncIterable<string>;
-}
-interface WriteResult {
-  bytes: number;
-  rowCount: number;
-}
-interface CodecCtx {
-  table: TableName;
-}
-/**
- * Key-oriented codec. Each method owns its I/O through `dataSource`:
- * - Node / browser codecs read/write bytes via `dataSource.read` / `.write`.
- * - Workers codecs let DuckDB's httpfs read/write remote URIs directly (via
- *   `dataSource.uri`) and never materialise bytes in JS.
- *
- * The engine never touches bytes; it just hands rows + keys to the codec.
- *
- * Invariants every implementation MUST uphold:
- * - `writeRows` with an empty `rows` array MUST still write a file
- *   carrying the canonical column set for `ctx.table` — a schema-correct
- *   empty file. No placeholder-column shortcuts; readers depend on the
- *   schema being present for `union_by_name` merges.
- * - `WriteResult.bytes` MUST be the real byte size written to the
- *   data source (not 0, not an estimate) so the engine can enforce the
- *   payload ceiling without a second `head` round-trip.
- * - `WriteResult.rowCount` MUST equal `rows.length` (or, for
- *   `compactRows`, the sum of input row counts).
- */
-interface ParquetCodec {
-  writeRows: (ctx: CodecCtx, rows: Row[], key: string, dataSource: DataSource) => Promise<WriteResult>;
-  readRows: (ctx: CodecCtx, key: string, dataSource: DataSource) => Promise<Row[]>;
-  compactRows: (ctx: CodecCtx, inputKeys: string[], outputKey: string, dataSource: DataSource) => Promise<WriteResult>;
-}
-declare function encodeRowsToParquet(table: TableName$1, rows: readonly Row$1[]): Uint8Array;
+import { N as TableName, a as DataSource, h as ParquetCodec, t as CodecCtx, w as Row } from "../_chunks/storage.mjs";
+import { t as ColumnDef } from "../_chunks/schema.mjs";
+declare function encodeRowsToParquet(table: TableName, rows: readonly Row[]): Uint8Array;
 interface EncodeFlexOptions {
   /** Columns defining the output schema + order. */
   columns: readonly ColumnDef[];
@@ -93,15 +16,15 @@ interface EncodeFlexOptions {
  * the canonical encoder so DuckDB `read_parquet(union_by_name = true)`
  * merges cleanly with fact-table reads.
  */
-declare function encodeRowsToParquetFlex(rows: readonly Row$1[], opts: EncodeFlexOptions): Uint8Array;
-declare function decodeParquetToRows(bytes: Uint8Array): Promise<Row$1[]>;
+declare function encodeRowsToParquetFlex(rows: readonly Row[], opts: EncodeFlexOptions): Uint8Array;
+declare function decodeParquetToRows(bytes: Uint8Array): Promise<Row[]>;
 interface HyparquetCodecOptions {
   /**
    * Override `readRows`. Useful when reads should be delegated to a faster
    * engine (e.g. DuckDB-WASM via httpfs) while writes + compaction stay on
    * hyparquet to avoid WASM linear-memory growth. Defaults to hyparquet.
    */
-  readRows?: (ctx: CodecCtx, key: string, dataSource: DataSource) => Promise<Row$1[]>;
+  readRows?: (ctx: CodecCtx, key: string, dataSource: DataSource) => Promise<Row[]>;
 }
 declare function createHyparquetCodec(options?: HyparquetCodecOptions): ParquetCodec;
 export { EncodeFlexOptions, HyparquetCodecOptions, createHyparquetCodec, decodeParquetToRows, encodeRowsToParquet, encodeRowsToParquetFlex };