@gscdump/cli 3.8.0 → 4.0.0

package/skills/gscdump/SKILL.md

@@ -10,6 +10,8 @@ It keeps a local Parquet Store for Google rows. Every command has `--help`.
 For `query`, `-s` means `--site`, `-d` means `--dimensions`, and `-f` means `--format`.
 Use `--start` and `--end` for dates. `--site=SITE` also works.
 Use each option once, with either its short or long spelling.
+Put options after the subcommand name: `gscdump store stats --json`, not `gscdump store --json stats`.
+A failed command prints one `Error:` line to stderr and exits 1.
 Example: `gscdump query --site=SITE --start=DATE --end=DATE -d page -f json`.
 
 ## Start each task
@@ -17,7 +19,7 @@ Example: `gscdump query --site=SITE --start=DATE --end=DATE -d page -f json`.
 1. Before reading traffic, run `gscdump auth status --json`. Do this even when the user says authentication works.
 2. Keep the requested Site, dates, dimensions, and task scope. A request for pages does not need query dimensions.
 3. Before local queries, check coverage with `gscdump store stats --site SITE --json`.
-   Use `gscdump sync --site SITE --status --json` when you need sync-state details.
+   Use `gscdump sync --site SITE --status --json` when you need coverage, gaps, or sync-state details.
 4. Read the table dimensions and watermarks. Sync only missing tables and the requested dates, once per task.
 5. Use `sync --json`. Read its completion result before deciding what to do next. Never repeat a successful sync.
 
@@ -29,6 +31,8 @@ Call the local data directory the Store in your answer.
 ## Authentication mode
 
 Check `gscdump auth status --json` before queries. Reuse the user's selected mode.
+In local mode, `googleAuthenticated: true` means Google accepted the credentials. When it is false, `googleError` says why.
+In cloud mode, `hostedSync` lists each gscdump.com Site with `syncStatus` and `syncProgress`. `gscdump sites` shows the same progress. The CLI does not read the hosted Store: cloud mode queries go to the live API through gscdump.com.
 
 | Mode | Credentials | Query path |
 | --- | --- | --- |
@@ -68,21 +72,45 @@ After cloud Bing login opens a browser, use `bing status --site s_SITE_ID` to co
 Hosted Bing commands use the API's plan and preview access rules.
 Hosted connection verification uses `bing verify --site s_SITE_ID`.
 Google Indexing API and Site Verification commands require local mode.
-Hosted sitemap membership and history require hosted credentials.
+Hosted sitemap reads and `indexing urls` require hosted credentials. Their `--site` takes a Site URL, such as `example.com`.
 
 ## Data boundaries
 
 - `sync`, `query --live`, `analyze --live`, `report --live`, `sites`,
   `sitemaps`, and `inspect` use the selected authentication mode.
 - Google Indexing API requests require local credentials. `indexing quota` only prints documented limits and needs no authentication.
-- `query`, `analyze`, `report`, `dump`, and `store` read the local Store by
-  default. If the Store has no rows for the Site, sync first or pass `--live`.
+- `dump` and `store` read the local Store only.
+- `query`, `analyze`, and `report` pick a source for each run. See [Routing](#routing).
 - Google returns a 2 to 3 day data delay. Default windows end three days ago.
 - Google omits low-volume rows. Pagination cannot recover them.
 - URL Inspection is limited to 2,000 requests per Site per day.
 - `indexing submit` and `indexing remove` are only for job posting and
   livestream pages. Google rejects other content.
 
+## Routing
+
+Login is optional. A user logs in (Google or hosted) or syncs a local Store.
+`query`, `analyze`, and `report` choose one source for each run. One run never
+mixes Store rows and live rows.
+
+| Store data for the Site | Google connected | Result |
+|---|---|---|
+| Covers every date the run needs | any | Answers from the Store, also while a sync runs |
+| None for the tables the run needs | yes | Answers from the live API. stderr says so, and JSON has `meta.source: "live"` |
+| None | no | Stops. Next command: `gscdump init` |
+| Some dates missing | yes | Stops with the exact `gscdump sync` command, or pass `--live` |
+| Some dates missing, a sync is running | yes | Stops with `Sync running: 41 of 90 days done.` Run again later, or pass `--live` |
+
+- `--live` always asks Search Console. It needs Google auth.
+- `query --sql` reads the Store only. It stops when no table it names has data.
+- JSON output carries `meta.source`: `local` or `live`.
+- A stop with `--format json` or `--json` prints `{ "error": { "code", "message", "nextCommand" } }` on stdout and exits 1.
+  Codes: `NOT_CONNECTED`, `STORE_RANGE_NOT_COVERED` (with `missingDates`), `SYNC_RUNNING` (with `sync.done` and `sync.total`), `NO_SYNCED_DATA`, `STORE_ONLY`, `LIVE_ONLY`.
+  Partial coverage and a running sync are normal progress. Run `nextCommand`, or tell the user to.
+- A sync is running only while its heartbeat is recent. A killed sync does not block reads.
+- Every Search Analytics, URL Inspection, and Indexing API call spends the shared quota ledger in the data dir.
+  When a quota is spent, the command stops at once and says when the quota resets.
+
 ## Get the binary
 
 ```sh
@@ -134,10 +162,18 @@ Cloud mode requires hosted access. Pro is free during beta, then paid after laun
 
 ## Site identifiers
 
-For Google, use the exact value that `gscdump sites` prints.
+For Google, pass the Site as the user writes it: `--site example.com`.
+`https://example.com`, `www.example.com`, and `Example.com` resolve to the same Site.
+Do not add `sc-domain:`.
 
-- Domain property: `sc-domain:example.com`
-- URL-prefix property: `https://example.com/` (trailing slash included)
+- The CLI checks Sites in the Store first. It asks Search Console only when the Store has no match and auth exists.
+- A full Site URL that names a property exactly, such as `https://example.com/`, picks that property.
+- Otherwise, if a domain property and a URL-prefix property both match, the CLI picks the one with Store data, then the domain property.
+- If a URL-prefix property has a path, include the path: `--site example.com/blog`.
+- If the input is a subdomain inside a domain property, the command fails. The error names the parent Site and a `--page` filter to use.
+- If the input matches more than one Site, the command fails and lists them. Pass one of the listed Site URLs.
+- Without `--site` and `defaultSite`, a command in a terminal shows a picker.
+  Without a terminal, the command fails with `Pass --site. Sites: ...`, unless only one Site is available.
 
 For cloud Bing commands, use a Site ID from `gscdump bing sites`, such as `s_SITE_ID`.
 For local Bing commands, use the full verified Site URL from `gscdump bing sites --mode local`.
@@ -146,7 +182,7 @@ Bing commands require their own explicit `--site`; the Google `defaultSite` sett
 Set a default once to drop `--site` from later commands:
 
 ```sh
-gscdump config set defaultSite sc-domain:example.com
+gscdump config set defaultSite example.com
 ```
 
 ## Output
@@ -174,17 +210,17 @@ Do not rewrite rows, estimate metrics, or add manually calculated totals.
 | `gscdump query` | Rows by page, query, date, country, or device |
 | `gscdump analyze <id>` | One Analyzer over the Store or live rows |
 | `gscdump report <id>` | A Report that composes several Analyzers |
-| `gscdump inspect <url>` | URL Inspection with Indexing Evidence |
+| `gscdump inspect <url...>` | URL Inspection with Indexing Evidence, saved to the Store |
 | `gscdump sitemaps` | List, submit, delete, and probe sitemaps |
-| `gscdump indexing` | Indexing API notifications and quota |
-| `gscdump dump` | Export Store tables to Parquet, CSV, JSON, or NDJSON |
+| `gscdump indexing` | Indexing API notifications and quota; hosted URL Inspection results |
+| `gscdump dump` | Export Store tables, inspections, sitemaps, and Bing data as Parquet, CSV, JSON, NDJSON, SQLite, or DuckDB |
 | `gscdump store` | Store stats, compaction, garbage collection, resets |
-| `gscdump entities` | Snapshot URL inspections into the entity store |
+| `gscdump entities` | Read saved inspections; snapshot Indexing API metadata |
 | `gscdump config` | Defaults such as `defaultSite`, `dataDir`, `defaultLimit` |
 | `gscdump profile` | Separate credential and config directories |
 | `gscdump auth` | `status`, `login`, `logout`, `refresh` |
 | `gscdump doctor` | Health checks for auth, scopes, Store, and reachability |
-| `gscdump init` | Interactive first-time setup |
+| `gscdump init` | First-time setup. Without a terminal it never prompts: it uses BYOK env credentials or fails with the auth command |
 | `gscdump mcp` | Start Google MCP tools with the selected authentication |
 | `gscdump skill install` | Copy this skill into an agent skill directory |
 | `gscdump papercut` | Report a CLI problem to gscdump.com |
@@ -192,29 +228,52 @@ Do not rewrite rows, estimate metrics, or add manually calculated totals.
 `gscdump login`, `gscdump logout`, and `gscdump status` are top-level aliases of
 the matching `auth` subcommands.
 The MCP server does not expose Bing tools. Use `gscdump bing` commands through this skill.
+`gscdump mcp` starts without authentication. Its Google tools then return an error with the command to run.
+A failed Google request returns its status, Google's explanation, and the next step in the tool result.
 
 ## Sync before local analysis
 
 ```sh
-gscdump store stats --site sc-domain:example.com --json
-gscdump sync --site sc-domain:example.com --days 90 \
-  --tables pages,queries,page_queries,countries --json
-gscdump sync --site sc-domain:example.com --status --json
+gscdump store stats --site example.com --json
+gscdump sync --site example.com --status --json
+gscdump sync --site example.com --json
 ```
 
-- Pass an explicit `--tables` list. The default list has a known daily-totals
-  limitation.
-- `--full` backfills the 450 days Google keeps.
+- A plain sync catches up. Each table runs from its oldest synced date to the
+  latest date Google has finalized (Pacific time, about 3 days late). A table
+  with no history starts 28 days back. Newest dates come first.
+- `--days N`, `--start`, and `--end` pick a range instead. `--full` fetches the
+  16 months Google keeps, plus 14 days Google often still serves.
+- Sync covers every table and search type by default. Pass `--tables` and
+  `--types` to sync less. Sync skips table and type pairs Google cannot answer.
+- Sync paces Google calls: 8 in flight and 600 per minute across all tables.
+  `--requests-per-minute N` changes the rate.
+  Sync does not retry a quota 403. The quota ledger stops the run instead.
+- Every call goes through a quota ledger in the Store directory. If Google
+  refuses a call for quota, or the run reaches `--max-calls N`, sync stops,
+  keeps the rest `pending`, and exits 0. `status` in `sync --json` is then
+  `partial` and `stopped` says why. Run the same command later to continue.
+  Exit 1 means real failures: read `failed` dates in `sync --status --json`.
+- Sync also saves the sitemap list, sitemap URLs, and URL Inspection results.
+  It inspects up to 50 due URLs per run: never-inspected sitemap URLs first,
+  then pages with impressions, then the oldest results. `--inspect-limit N`
+  changes that; Google allows 2,000 per Site per day. `--no-sitemaps` and
+  `--no-inspections` skip those steps.
+- `coverage` in `sync --json` and `sync --status --json` says how much the
+  Store holds. Partial coverage is normal progress. Never report data as
+  complete unless its `kind` is `complete`.
+- A day Google still updates stays `pending`; the next sync fetches it again.
 - Sync skips completed dates. `--force` refreshes them. `--retry-failed`
-  reruns only failed dates.
-- `--dry-run` prints the planned work without calling Google.
-- Use the user's date range. The 90-day example does not authorize a wider sync.
+  reruns only failed dates. A plain sync also retries failed dates.
+- `--dry-run` prints the planned dates and the fewest calls without calling Google.
+- `--all-sites` syncs every verified Site, one after another.
+- Use the user's date range. If the user names a range, pass `--start` and `--end`, not `--full`.
 - Empty Store metadata is expected before the first sync. It does not prove zero traffic.
 
 ## Query rows
 
 ```sh
-gscdump query --site sc-domain:example.com --dimensions page,query \
+gscdump query --site example.com --dimensions page,query \
   --start 2026-08-01 --end 2026-08-28 --limit 1000 --format json
 ```
 
@@ -222,33 +281,89 @@ gscdump query --site sc-domain:example.com --dimensions page,query \
 - Filters: `--query`, `--page`, `--country`, `--device`,
   `--search-appearance`. Prefixes: bare equals, `~` contains, `!~` not
   contains, `re:` regex, `!re:` not regex, `!` not equals.
-- `--live` bypasses the Store. `--type` selects a search type.
+- `--page` takes a path or a full URL. The Store compares paths.
+- Without dates, `query` reads the 28 days ending on the newest synced day.
+- `--live` bypasses the Store. `--type` selects a search type. The default is `web`.
   `--data-state` and `--aggregation-type` apply to live mode only.
 - Metrics already include clicks, impressions, CTR, and position. There is no `--metrics` option.
-- If Store coverage is missing, read the JSON error and its bounded `nextArgs` before syncing.
+- If Store coverage is missing, read the JSON error and run its `nextCommand`. It syncs only the missing dates and tables.
   Do not switch dimensions to make a failed query succeed.
 - `--explain` prints the request body or planned SQL without executing.
-- `--sql` runs raw DuckDB SQL over the Store with `{{FILES}}` as the file list.
+
+## SQL over the Store
+
+```sh
+gscdump query --schema --format json
+gscdump query --format json --sql "SELECT search_type, SUM(clicks) AS clicks,
+  gsc_position(sum_position, impressions) AS position
+  FROM pages WHERE date >= DATE '2026-08-01' GROUP BY search_type"
+```
+
+- `--sql` runs DuckDB SQL over one view per Store table: `pages`, `queries`,
+  `page_queries`, `countries`, `dates`, `hourly_pages`, and the
+  `search_appearance*` tables. Join views on `site`, `search_type`, `url`, and `date`.
+- `--schema` lists each view, its columns, its Sites, and its date range.
+- Every view has `site` (the Site URL) and `search_type`. The Store keeps
+  every search type, so filter or group by `search_type`. A plain `SUM` adds
+  web, image, and Discover rows together.
+- `url` holds the page path. `page` is the same value.
+- `sum_position` is the zero-based position times impressions. Use
+  `gsc_position(sum_position, impressions)` for the average position. It adds 1
+  and weights by impressions. Never average a per-row position.
+- The views cover every Site in the Store. `--site` and `--type` narrow them.
+- Dates return as `YYYY-MM-DD`. Integers return as numbers.
+- If a query names a table with no synced data, the JSON has a `warnings` list.
+
+## Export the Store
+
+```sh
+gscdump dump --site example.com --format parquet --out ./export
+gscdump dump --all-sites --format sqlite --out ./export
+```
+
+- `dump` reads only the Store. It never calls Google to fill a gap.
+- Every exported row has `site` and `search_type`.
+- File formats write `<site>/<search_type>/<table>.<ext>` and
+  `<site>/<dataset>.<ext>` for inspections, sitemaps, and Indexing API metadata.
+- `csv`, `json`, and `ndjson` rows also have `position`: `sum_position / impressions + 1`.
+- `sqlite` and `duckdb` write one file, `gscdump.sqlite` or `gscdump.duckdb`,
+  with one table per dataset for every Site and search type.
+- `manifest.json` lists every dataset with its row count, plus the coverage that `sync --status --json` reports. Partial coverage is progress: daily sync fills the rest.
+- `sites.json` lists each exported Site URL with its Store ID.
 
 ## Analyze and report
 
 ```sh
 gscdump report list --json
-gscdump report opportunities --site sc-domain:example.com --json
-gscdump report movers --site sc-domain:example.com --period 28d --vs prev-period --json
+gscdump report opportunities --site example.com --json
+gscdump report movers --site example.com --period 28d --vs prev-period --json
 gscdump analyze list --json
-gscdump analyze striking-distance --site sc-domain:example.com --json
+gscdump analyze striking-distance --site example.com --json
 ```
 
 - Report ids: `brand`, `growth`, `health`, `movers`, `opportunities`,
   `pre-publish`, `risks`, `triage`.
-- `--period` takes `7d`, `28d`, `90d`, `mtd`, `ytd`, or `custom` with
-  `--start` and `--end`. `--vs` takes `none`, `prev-period`, or `yoy`.
+- `--period` takes `7d`, `28d`, `30d`, `90d`, `180d`, `365d`, `mtd`, `qtd`,
+  `ytd`, `last-quarter`, or `custom`. `--start`/`--end` without `--period`
+  select a custom window. `--vs` takes `none`, `prev-period`, or `yoy`
+  (same weekdays 52 weeks earlier).
+- Windows end on the newest synced day, or three days ago (Pacific time)
+  with `--live`. They never end on today.
 - `report <id> --explain` prints the plan without credentials or data.
 - `triage` needs `--target <page-or-query> --target-kind page|query`.
   `pre-publish` needs `--topic`. `brand` needs `--brand-terms 'a,b'`.
-- Analyzers take `--start` and `--end`. `movers` and `decay` also take
-  `--prev-start` and `--prev-end`. `--period` and `--vs` belong to `report`.
+- Analyzers take `--period`, `--start` and `--end`. `movers` and `decay`
+  compare with the previous period by default. Pass `--prev-start` and
+  `--prev-end` together to override it. `--vs` belongs to `report`.
+- `--limit` caps the rows returned. It never caps the rows read.
+  `--fetch-budget` caps each live fetch (default 25000, max 100000).
+- A `! Partial data` warning, or `meta.coverage.kind: "truncated"` in JSON,
+  means a live fetch hit its budget. Say the result is partial, or rerun
+  with a larger `--fetch-budget`.
+- Local `analyze` and `report` runs need every day of the current and
+  comparison windows synced. If a day is missing, failed or pending, the
+  run stops and prints the `gscdump sync --site ... --start ... --end ...
+  --tables ...` command that fills it. Run it, or pass `--live`.
 - SQL-only Analyzers need Store rows. `--live` runs row-based Analyzers
   against Google.
 - Results name candidates for review. They do not prove why traffic changed.
@@ -256,15 +371,30 @@ gscdump analyze striking-distance --site sc-domain:example.com --json
 ## Inspect and index
 
 ```sh
-gscdump inspect https://example.com/page --site sc-domain:example.com --json
-gscdump inspect batch --site sc-domain:example.com --file urls.txt --json
+gscdump inspect https://example.com/page https://example.com/other --site example.com --json
+gscdump inspect --site example.com --file urls.txt --json
 gscdump indexing quota --json
 ```
 
-Inspection spends Google's separate 2,000 requests per Site per day quota.
+Inspection spends Google's separate quota: 2,000 requests per day and 600 per minute for each property.
+`inspect` refuses more than 2,000 URLs in one run. It saves each result to the Store.
+On a quota error it stops and reports `remaining`. It exits 1 when any URL fails or remains.
 `indexing quota` describes Indexing API limits. It does not report remaining URL Inspection requests.
 Report the Indexing Evidence fields as Google returned them.
 
+## Find URLs Google has not indexed (hosted)
+
+```sh
+gscdump indexing urls --site example.com --status not_indexed --json
+gscdump indexing urls --site example.com --status not_indexed --all --format csv
+```
+
+- The command reads URL Inspection results that gscdump.com already saved. It spends no inspection quota.
+- `--status` takes `indexed`, `not_indexed`, or `pending`. `--search` keeps URLs that contain the text.
+- Each row lists the sitemaps that contain the URL.
+- Pages hold 100 rows by default and 500 at most. Use `--offset` for the next page, or `--all` for every page.
+- With local authentication, the command fails. Pipe `gscdump sitemaps urls <sitemap-url>` into `gscdump inspect --site <site>` instead.
+
 ## Report a papercut
 
 If CLI behavior blocks or slows your work, report it once per distinct

package/dist/commands/export.mjs

@@ -1,76 +0,0 @@
-import { OUTPUT_ARGS, applyOutputMode, displayPath } from "../utils.mjs";
-import { allTables } from "../local-store.mjs";
-import { createCommandContext } from "../context.mjs";
-import { materializeParquetTables } from "../native-duckdb.mjs";
-import { defineCommand } from "citty";
-import path from "node:path";
-async function exportToDuckDB(opts) {
-	const outPath = path.resolve(opts.outPath);
-	const entries = await opts.engine.listLive({
-		userId: opts.userId,
-		siteId: opts.siteId
-	});
-	const inputs = [];
-	for (const table of allTables()) {
-		const tableEntries = entries.filter((entry) => entry.table === table);
-		if (tableEntries.length > 0) inputs.push({
-			table,
-			filePaths: tableEntries.map((entry) => path.join(opts.dataDir, entry.objectKey))
-		});
-	}
-	const tables = await materializeParquetTables(outPath, inputs, opts.force);
-	return {
-		outPath,
-		tables,
-		totalRows: tables.reduce((acc, t) => acc + t.rows, 0)
-	};
-}
-const exportCommand = defineCommand({
-	meta: {
-		name: "export",
-		description: "Pack live Parquet partitions into a single .duckdb file for portable distribution (browser attach, CDN serving, etc.)"
-	},
-	args: {
-		out: {
-			type: "string",
-			required: true,
-			description: "Output path for the .duckdb file"
-		},
-		site: {
-			type: "string",
-			description: "Limit export to a single site URL (omit to include all)"
-		},
-		force: {
-			type: "boolean",
-			default: false,
-			description: "Overwrite the output file if it already exists"
-		},
-		...OUTPUT_ARGS
-	},
-	async run({ args }) {
-		const { json } = applyOutputMode(args);
-		const store = (await createCommandContext({ needsStore: true })).store;
-		const siteId = args.site ? store.siteIdFor(args.site) : void 0;
-		const result = await exportToDuckDB({
-			engine: store.engine,
-			dataDir: store.dataDir,
-			userId: store.userId,
-			siteId,
-			outPath: args.out,
-			force: args.force
-		});
-		if (json) {
-			console.log(JSON.stringify(result, null, 2));
-			return;
-		}
-		if (result.tables.length === 0) {
-			console.log(`\n  No data to export. Run \`gscdump sync\` first.`);
-			return;
-		}
-		for (const t of result.tables) console.log(`  ${t.table.padEnd(15)} ${String(t.files).padStart(4)} parquet → ${t.table}  (${t.rows.toLocaleString()} rows)`);
-		console.log(`\n  Exported ${result.tables.length} table(s), ${result.totalRows.toLocaleString()} rows → ${displayPath(result.outPath)}`);
-		console.log(`\n  Attach from DuckDB:     \x1B[36mATTACH '${result.outPath}' AS gsc (READ_ONLY); SELECT * FROM gsc.pages LIMIT 10;\x1B[0m`);
-		console.log(`  Attach in a browser:    use DuckDB-WASM registerFileBuffer + \x1B[36mATTACH 'gsc.duckdb' AS gsc (READ_ONLY)\x1B[0m`);
-	}
-});
-export { exportCommand, exportToDuckDB };

package/dist/native-duckdb.mjs

@@ -1,46 +0,0 @@
-import { rm } from "node:fs/promises";
-import { dateColumnsFor } from "@gscdump/engine/schema";
-import { sqlEscape } from "@gscdump/engine/sql";
-import { dateReplaceClause } from "@gscdump/engine/sql-fragments";
-function parquetFileListSql(filePaths) {
-	return filePaths.map((filePath) => `'${sqlEscape(filePath)}'`).join(", ");
-}
-async function loadDuckDB() {
-	return import("@duckdb/node-api");
-}
-async function readParquetRows(filePaths, table) {
-	const { DuckDBInstance } = await loadDuckDB();
-	const instance = await DuckDBInstance.create(":memory:");
-	const conn = await instance.connect();
-	try {
-		const replace = dateReplaceClause(dateColumnsFor(table), "string");
-		return (await conn.runAndReadAll(`SELECT * ${replace} FROM read_parquet([${parquetFileListSql(filePaths)}], union_by_name=true)`)).getRowObjects();
-	} finally {
-		conn.closeSync();
-		instance.closeSync();
-	}
-}
-async function materializeParquetTables(outPath, tables, force = false) {
-	if (force) await rm(outPath, { force: true });
-	const { DuckDBInstance } = await loadDuckDB();
-	const instance = await DuckDBInstance.create(outPath);
-	const conn = await instance.connect();
-	const results = [];
-	try {
-		for (const input of tables) {
-			const replace = dateReplaceClause(dateColumnsFor(input.table), "date");
-			await conn.run(`CREATE OR REPLACE TABLE ${input.table} AS SELECT * ${replace} FROM read_parquet([${parquetFileListSql(input.filePaths)}], union_by_name=true)`);
-			const rows = (await conn.runAndReadAll(`SELECT count(*)::BIGINT AS n FROM ${input.table}`)).getRowObjects();
-			results.push({
-				table: input.table,
-				files: input.filePaths.length,
-				rows: Number(rows[0]?.n ?? 0)
-			});
-		}
-	} finally {
-		conn.closeSync();
-		instance.closeSync();
-	}
-	return results;
-}
-export { materializeParquetTables, readParquetRows };