@gscdump/cli 3.8.0 → 4.0.1

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,9 +19,11 @@ 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.
+   On a fresh Store, `store stats` exits 1 and says it has no data. Continue with the bounded sync.
 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.
+6. If the user asks for saved rows, check `meta.source: "local"` in the query result. A successful query can answer live when its table has no synced data.
 
 If the task only asks about deletion, explain the scope and ask for consent.
 You may read Store metadata with `store stats` and `sync --status`.
@@ -29,6 +33,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 +74,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 +164,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 +184,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 +212,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,63 +230,145 @@ 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`.
+- If the user excludes rollups, pass `--no-rollups` on the sync command.
 - 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
 ```
 
 - Dimension names are singular: `page`, `query`, `date`, `country`, `device`.
+- A page breakdown uses `--tables pages` for sync and `-d page` for query.
+  `-d page,query` needs `page_queries`; syncing only `pages` does not fill that table.
 - 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 +376,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 };