@gscdump/engine 0.32.6 → 0.32.8

package/dist/_chunks/libs/icebird.d.mts

@@ -303,7 +303,8 @@ declare function icebergAppend({
   tableUrl,
   resolver,
   records,
-  sortOrderId
+  sortOrderId,
+  snapshotProperties
 }: {
   catalog: Catalog;
   namespace?: string | string[] | undefined;
@@ -312,6 +313,7 @@ declare function icebergAppend({
   resolver?: Resolver | undefined;
   records: Record<string, any>[];
   sortOrderId?: number | undefined;
+  snapshotProperties?: Record<string, string> | undefined;
 }): Promise<TableMetadata>;
 /**
  * Create a new table. REST: delegates to the catalog's create endpoint.

package/dist/_chunks/libs/icebird.mjs

@@ -3216,7 +3216,7 @@ async function prepareAppend({ tableUrl, metadata, records, resolver, sortOrderI
 		writtenFiles: [...writtenDataFiles.map((f) => f.path), manifestPath]
 	};
 }
-async function stageSnapshotForAppend({ tableUrl, metadata, prepared, resolver }) {
+async function stageSnapshotForAppend({ tableUrl, metadata, prepared, resolver, snapshotProperties }) {
 	if (!tableUrl) throw new Error("tableUrl is required");
 	if (!resolver?.writer) throw new Error("resolver.writer is required");
 	const sequenceNumber = BigInt(metadata["last-sequence-number"] ?? 0) + 1n;
@@ -3254,7 +3254,8 @@ async function stageSnapshotForAppend({ tableUrl, metadata, prepared, resolver }
 		"total-data-files": String(prevTotals.files + BigInt(prepared.addedDataFilesCount)),
 		"total-delete-files": "0",
 		"total-position-deletes": "0",
-		"total-equality-deletes": "0"
+		"total-equality-deletes": "0",
+		...snapshotProperties ?? {}
 	};
 	return await buildSnapshotUpdate({
 		tableUrl,
@@ -3370,7 +3371,7 @@ const DEFAULT_RETRY = Object.freeze({
 	factor: 2,
 	totalTimeoutMs: 1800 * 1e3
 });
-async function icebergAppend({ catalog, namespace, table, tableUrl, resolver, records, sortOrderId }) {
+async function icebergAppend({ catalog, namespace, table, tableUrl, resolver, records, sortOrderId, snapshotProperties }) {
 	const ctx = await loadTable({
 		catalog,
 		namespace,
@@ -3396,7 +3397,8 @@ async function icebergAppend({ catalog, namespace, table, tableUrl, resolver, re
 			tableUrl: workingCtx.tableUrl,
 			metadata: workingCtx.metadata,
 			prepared,
-			resolver: requireResolver(workingCtx.resolver, "icebergAppend")
+			resolver: requireResolver(workingCtx.resolver, "icebergAppend"),
+			snapshotProperties
 		})
 	});
 }

package/dist/_chunks/sink.d.mts

@@ -283,6 +283,14 @@ interface CommitRetryOptions {
   sleep?: (ms: number) => Promise<void>;
   /** Injectable RNG for the jitter — tests pass a deterministic value. */
   random?: () => number;
+  /**
+   * Idempotency token stamped into the appended snapshot's summary
+   * (`gscdump.append-id`) and matched by the landed-check before any outer
+   * retry. Generated per call (`crypto.randomUUID`) so it is STABLE across this
+   * call's retries but UNIQUE per call — a content hash would risk a false
+   * "already landed" skip (silent data loss). Injectable for deterministic tests.
+   */
+  appendId?: string;
 }
 /**
  * True when `err` is an R2 Data Catalog commit rate-limit response
@@ -297,15 +305,18 @@ declare function isCommitRateLimited(err: unknown): boolean;
  * retries 412/409 internally; 429 is the gap this closes. Non-429 errors
  * (and 429s that survive every attempt) propagate unchanged.
  *
- * RESIDUAL RISK — re-upload orphans. icebird's `icebergAppend` prepares the
- * data + manifest files ONCE, outside its internal 412/409 retry loop, so
- * those retries never re-upload data. A 429 that escapes that loop and is
- * retried HERE re-runs the whole `icebergAppend` call, which re-prepares and
- * re-uploads the data files; the previous attempt's parquet objects become
- * orphans (referenced by no snapshot). 429s should be rare and clear within
- * an attempt or two, so orphan volume is small, and R2 orphan-file cleanup
- * reclaims them. Eliminating the 429 source entirely (per-table commit
- * coalescing) is assessed in the Phase-1.5 report.
+ * IDEMPOTENT RE-RUN. A 429 that escapes icebird's internal loop is retried HERE
+ * by re-running the whole `icebergAppend`, which re-prepares + re-uploads the
+ * data files. That is safe ONLY if the prior attempt's commit did NOT land — but
+ * R2 Data Catalog can apply a commit and STILL return 429 (rate-limit on the
+ * response path), and a lost ack looks identical. A blind re-run then appends a
+ * SECOND copy of the same rows → silent double-count (observed: a re-resynced
+ * site read 2× its true totals). To close this, every attempt stamps a per-call
+ * `gscdump.append-id` into the snapshot summary, and BEFORE retrying or giving
+ * up we reload the table and check whether that id already landed
+ * ({@link appendAlreadyLanded}); if so the append succeeded and we return without
+ * re-appending. A non-landed 429 still re-runs (the previous attempt's parquet is
+ * an orphan, reclaimed by R2 cleanup) — same as before, no double.
  */
 declare function icebergAppendRetrying(args: Parameters<typeof icebergAppend>[0], options?: CommitRetryOptions): Promise<void>;
 /**
@@ -443,6 +454,10 @@ interface SinkCapabilities {
   /** Whether the sink exposes partition overwrite semantics. */
   canOverwrite?: boolean;
 }
+/** Partition-overwrite writer for revision paths. */
+interface SliceOverwriteWriter {
+  overwriteSlice: (slice: SinkSlice, rows: readonly Row$1[]) => Promise<SinkWriteResult>;
+}
 /**
  * Outcome of `Sink.close()` — which tables' buffered rows reached durable
  * storage and which failed.
@@ -528,4 +543,4 @@ interface LocalIcebergSinkOptions extends SinkOptions {
   /** S3-compatible warehouse location (POC: MinIO). */
   warehouse: string;
 }
-export { CatalogCache, CommitRetryOptions, ConnectIcebergOptions, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_TABLES, INT_SEARCH_TYPE, IcebergAppendSinkOptions, IcebergCatalogConfig, IcebergColumn, IcebergColumnType, IcebergConnection, IcebergListedDataFile, IcebergPartitionField, IcebergPartitionSpec, IcebergPartitionSpecField, IcebergPartitionTransform, IcebergPrimitiveType, IcebergS3Config, IcebergSchema, IcebergSchemaField, IcebergSortOrder, IcebergSortOrderField, IcebergTableName, IcebergTableOpResult, IcebergTableSpec, ListIcebergDataFilesOptions, LocalIcebergSinkOptions, PartitionKeyEncoding, SEARCH_TYPE_INT, Sink, SinkCapabilities, SinkCloseResult, SinkOptions, SinkSlice, SinkWriteResult, assertIcebergTable, connectIcebergCatalog, createIcebergTables, dropIcebergTables, ensureIcebergNamespace, icebergAppendRetrying, icebergPartitionColumns, icebergPartitionSpecFor, icebergSchemaFor, icebergSchemasFor, icebergSortOrderFor, icebergTableSpec, isCommitRateLimited, isIcebergTable, listIcebergDataFiles, listIcebergTables };
+export { CatalogCache, CommitRetryOptions, ConnectIcebergOptions, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_TABLES, INT_SEARCH_TYPE, IcebergAppendSinkOptions, IcebergCatalogConfig, IcebergColumn, IcebergColumnType, IcebergConnection, IcebergListedDataFile, IcebergPartitionField, IcebergPartitionSpec, IcebergPartitionSpecField, IcebergPartitionTransform, IcebergPrimitiveType, IcebergS3Config, IcebergSchema, IcebergSchemaField, IcebergSortOrder, IcebergSortOrderField, IcebergTableName, IcebergTableOpResult, IcebergTableSpec, ListIcebergDataFilesOptions, LocalIcebergSinkOptions, PartitionKeyEncoding, SEARCH_TYPE_INT, Sink, SinkCapabilities, SinkCloseResult, SinkOptions, SinkSlice, SinkWriteResult, SliceOverwriteWriter, assertIcebergTable, connectIcebergCatalog, createIcebergTables, dropIcebergTables, ensureIcebergNamespace, icebergAppendRetrying, icebergPartitionColumns, icebergPartitionSpecFor, icebergSchemaFor, icebergSchemasFor, icebergSortOrderFor, icebergTableSpec, isCommitRateLimited, isIcebergTable, listIcebergDataFiles, listIcebergTables };

package/dist/iceberg/index.mjs

@@ -173,6 +173,8 @@ async function connectIcebergCatalog(config, opts = {}) {
 		namespace: config.namespace
 	};
 }
+const APPEND_ID_SUMMARY_KEY = "gscdump.append-id";
+const APPEND_LANDED_SCAN_DEPTH = 25;
 function isCommitRateLimited(err) {
 	if (err && typeof err === "object" && err.status === 429) return true;
 	const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
@@ -187,14 +189,35 @@ async function icebergAppendRetrying(args, options = {}) {
 	const maxDelayMs = options.maxDelayMs ?? 2e4;
 	const sleep = options.sleep ?? defaultCommitSleep;
 	const random = options.random ?? Math.random;
+	const appendId = options.appendId ?? globalThis.crypto.randomUUID();
+	const stampedArgs = {
+		...args,
+		snapshotProperties: {
+			...args.snapshotProperties,
+			[APPEND_ID_SUMMARY_KEY]: appendId
+		}
+	};
 	for (let attempt = 0; attempt < maxAttempts; attempt++) {
-		const err = await icebergAppend(args).then(() => void 0, (e) => e);
+		const err = await icebergAppend(stampedArgs).then(() => void 0, (e) => e);
 		if (err === void 0) return;
+		if (await appendAlreadyLanded(args, appendId).catch(() => false)) return;
 		if (!isCommitRateLimited(err) || attempt === maxAttempts - 1) throw err;
 		const ceiling = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt);
 		await sleep(Math.floor(random() * ceiling));
 	}
 }
+async function appendAlreadyLanded(args, appendId) {
+	const a = args;
+	if (a.catalog?.type !== "rest" || a.namespace == null || a.table == null) return false;
+	const { metadata } = await restCatalogLoadTable(a.catalog, {
+		namespace: a.namespace,
+		table: a.table
+	});
+	const snapshots = metadata.snapshots ?? [];
+	const from = Math.max(0, snapshots.length - APPEND_LANDED_SCAN_DEPTH);
+	for (let i = snapshots.length - 1; i >= from; i--) if (snapshots[i]?.summary?.[APPEND_ID_SUMMARY_KEY] === appendId) return true;
+	return false;
+}
 async function ensureIcebergNamespace(conn) {
 	await restCatalogCreateNamespace(conn.catalog, { namespace: conn.namespace }).catch(() => {});
 }

package/dist/sink-node.d.mts

@@ -1,4 +1,5 @@
-import { IcebergS3Config, LocalIcebergSinkOptions, Sink } from "./_chunks/sink.mjs";
+import { Row } from "./_chunks/storage.mjs";
+import { IcebergS3Config, LocalIcebergSinkOptions, Sink, SinkCloseResult, SliceOverwriteWriter } from "./_chunks/sink.mjs";
 /** Full `LocalIcebergSink` options — extends the frozen contract options. */
 interface LocalIcebergSinkFullOptions extends LocalIcebergSinkOptions {
   /** S3 credentials for the warehouse. Defaults to the POC MinIO creds. */
@@ -21,4 +22,162 @@ interface LocalIcebergSink extends Sink {
  * use this sink must skip when the stack is unreachable.
  */
 declare function createLocalIcebergSink(options: LocalIcebergSinkFullOptions): LocalIcebergSink;
-export { type LocalIcebergSink, type LocalIcebergSinkFullOptions, type LocalIcebergSinkOptions, createLocalIcebergSink };
+/** Connection details for the Iceberg REST catalog the writer targets. */
+interface OverwriteWriterCatalogConfig {
+  /**
+   * Iceberg REST catalog endpoint, e.g. `http://localhost:8181` (POC) or the
+   *  R2 Data Catalog endpoint (prod).
+   */
+  catalogUri: string;
+  /** Catalog namespace the 5 fact tables live under, e.g. `gsc`. */
+  namespace: string;
+  /** Warehouse identifier the catalog resolves table locations under. */
+  warehouse: string;
+  /** S3-compatible object store backing the catalog. */
+  s3: IcebergS3Config;
+  /** Bearer token for a token-authed REST catalog (R2 Data Catalog). */
+  catalogToken?: string;
+}
+/**
+ * The JSON job wire-format shared with `scripts/iceberg-writer.py` — identical
+ * to the shape `LocalIcebergSink` already emits, so one PyIceberg script backs
+ * both the local sink and this writer. `op` is always `overwrite` here.
+ */
+interface OverwriteJob {
+  op: 'overwrite';
+  catalogUri: string;
+  namespace: string;
+  warehouse: string;
+  s3: IcebergS3Config;
+  table: string;
+  spec: unknown;
+  siteId: string;
+  searchType: string;
+  date: string;
+  /** Data columns only — the script injects `site_id` / `search_type`. */
+  rows: readonly Row[];
+}
+/**
+ * Per-site delete job — removes EVERY row for one `siteId` across a whole
+ * table (all dates / search types). Recovery op for clearing a corrupt site
+ * (e.g. a cross-run append double) from a shared per-team shard before a clean
+ * re-backfill, without touching sibling sites. Carries no rows. `siteId` is a
+ * `number` for an INT-encoded shard, a `string` for STRING encoding.
+ */
+interface DeleteJob {
+  op: 'delete';
+  catalogUri: string;
+  namespace: string;
+  warehouse: string;
+  s3: IcebergS3Config;
+  /** Bearer token for a token-authed REST catalog (R2 Data Catalog). */
+  catalogToken?: string;
+  table: string;
+  siteId: string | number;
+}
+/** Any job the shared PyIceberg backend can execute. */
+type PyIcebergJob = OverwriteJob | DeleteJob;
+/** Result wire-format from the PyIceberg backend. */
+interface OverwriteJobResult {
+  /** Rows written (emit/overwrite) or removed (delete). */
+  rowCount?: number;
+  error?: string;
+}
+/**
+ * A transport that executes one PyIceberg job and returns its result.
+ * `subprocessBackend` and `httpBackend` are the two shipped implementations;
+ * tests inject a fake. The param is the `OverwriteJob | DeleteJob` union, so a
+ * backend value is still assignable where the narrower `OverwriteBackend` is
+ * expected (a wider-param function accepts the narrower call).
+ */
+type OverwriteBackend = (job: PyIcebergJob) => Promise<OverwriteJobResult>;
+interface IcebergOverwriteWriterOptions {
+  catalog: OverwriteWriterCatalogConfig;
+  /** The transport that runs the PyIceberg job. */
+  backend: OverwriteBackend;
+}
+/**
+ * The trailing-window Iceberg overwrite writer. Conforms to the frozen
+ * `SliceOverwriteWriter` contract; `overwriteSlice` builds one PyIceberg
+ * overwrite job per call and runs it through the configured backend.
+ */
+interface IcebergOverwriteWriter extends SliceOverwriteWriter {
+  /** Release any backend resources. Idempotent. */
+  close: () => Promise<SinkCloseResult>;
+}
+/**
+ * Build a trailing-window Iceberg overwrite writer over the given backend.
+ * Pure — all I/O is the backend's; the writer only shapes the job.
+ */
+declare function createIcebergOverwriteWriter(opts: IcebergOverwriteWriterOptions): IcebergOverwriteWriter;
+/** Options for the PyIceberg subprocess backend. */
+interface SubprocessBackendOptions {
+  /** Python interpreter. Defaults to `$GSCDUMP_ICEBERG_PYTHON` then `python3`. */
+  python?: string;
+  /**
+   * Path to the PyIceberg writer script. Defaults to
+   *  `<engine>/scripts/iceberg-writer.py`.
+   */
+  writerScript?: string;
+}
+/**
+ * Backend that runs the PyIceberg overwrite by spawning the shared writer
+ * script (`scripts/iceberg-writer.py`). Node-only — used by local integration
+ * tests and a Node-side scheduled job box. The script reads the job JSON on
+ * stdin and writes `{rowCount}` / `{error}` on stdout.
+ */
+declare function subprocessBackend(opts?: SubprocessBackendOptions): OverwriteBackend;
+/** Options for the PyIceberg HTTP backend (the Cloudflare Container in prod). */
+interface HttpBackendOptions {
+  /**
+   * URL of the PyIceberg overwrite service — a POST endpoint accepting the
+   *  `OverwriteJob` JSON and returning `OverwriteJobResult`.
+   */
+  endpoint: string;
+  /** Optional bearer token for the service. */
+  token?: string;
+  /** Injectable fetch — defaults to the global. */
+  fetch?: typeof fetch;
+}
+/**
+ * Backend that POSTs the overwrite job to a PyIceberg HTTP service — the
+ * Cloudflare Container running `iceberg-writer.py` behind an HTTP shim. This
+ * is the prod transport: the request-path Worker holds no Python and never
+ * does an Iceberg metadata commit itself.
+ */
+declare function httpBackend(opts: HttpBackendOptions): OverwriteBackend;
+/**
+ * Adapt an `IcebergOverwriteWriter` into a full `Sink` whose `emit` is also a
+ * partition-overwrite — convenient for tests so a single Iceberg writer backs
+ * both append and revision paths against the local stack. Prod keeps `emit`
+ * on the Pipeline; only `overwriteSlice` delegates here.
+ */
+declare function overwriteWriterAsSink(writer: IcebergOverwriteWriter): Sink & SliceOverwriteWriter;
+/** Per-table outcome of a {@link deleteSiteFromShard} run. */
+interface DeleteSiteResult {
+  table: string;
+  /** Rows removed, when the backend reported a count. */
+  rowCount?: number;
+  /** Present when this table's delete failed; the sweep continues regardless. */
+  error?: string;
+}
+/**
+ * Remove every row for one `siteId` from a per-team Iceberg shard, across the
+ * given tables. Recovery op: clear a corrupt site (e.g. a cross-run append
+ * double) before a clean re-backfill, leaving sibling sites in the shared shard
+ * untouched. `site_id` is an identity partition column, so PyIceberg prunes
+ * whole data files (no row-level delete files).
+ *
+ * Runs SEQUENTIALLY (one commit per table at a time) so the per-table catalog
+ * commit-rate ceiling is never tripped. A table failure is captured in its
+ * result row, not thrown — the sweep always attempts every table so a partial
+ * failure is visible and re-runnable (delete is idempotent: re-deleting an
+ * already-empty site is a no-op).
+ */
+declare function deleteSiteFromShard(args: {
+  catalog: OverwriteWriterCatalogConfig;
+  backend: OverwriteBackend;
+  siteId: string | number;
+  tables: readonly string[];
+}): Promise<DeleteSiteResult[]>;
+export { type DeleteJob, type DeleteSiteResult, type IcebergOverwriteWriter, type IcebergOverwriteWriterOptions, type LocalIcebergSink, type LocalIcebergSinkFullOptions, type LocalIcebergSinkOptions, type OverwriteBackend, type OverwriteJob, type OverwriteJobResult, type OverwriteWriterCatalogConfig, type PyIcebergJob, createIcebergOverwriteWriter, createLocalIcebergSink, deleteSiteFromShard, httpBackend, overwriteWriterAsSink, subprocessBackend };

package/dist/sink-node.mjs

@@ -1,4 +1,4 @@
-import { ICEBERG_SCHEMAS } from "./_chunks/schema2.mjs";
+import { ICEBERG_SCHEMAS, assertIcebergTable } from "./_chunks/schema2.mjs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import process from "node:process";
@@ -83,4 +83,102 @@ function createLocalIcebergSink(options) {
 		}
 	};
 }
-export { createLocalIcebergSink };
+function createIcebergOverwriteWriter(opts) {
+	const { catalog, backend } = opts;
+	async function overwriteSlice(slice, rows) {
+		const siteId = slice.ctx.siteId;
+		if (!siteId) throw new Error("overwriteSlice: slice.ctx.siteId is required for the Iceberg partition key");
+		const table = assertIcebergTable(slice.table);
+		const res = await backend({
+			op: "overwrite",
+			catalogUri: catalog.catalogUri,
+			namespace: catalog.namespace,
+			warehouse: catalog.warehouse,
+			s3: catalog.s3,
+			table,
+			spec: ICEBERG_SCHEMAS[table],
+			siteId,
+			searchType: slice.searchType,
+			date: slice.date,
+			rows
+		});
+		if (res.error) throw new Error(`overwriteSlice: PyIceberg backend failed: ${res.error}`);
+		return { rowCount: res.rowCount ?? rows.length };
+	}
+	return {
+		overwriteSlice,
+		async close() {
+			return {
+				flushed: [],
+				failed: []
+			};
+		}
+	};
+}
+function subprocessBackend(opts = {}) {
+	return async (job) => {
+		const { dirname, join } = await import("node:path");
+		const { fileURLToPath } = await import("node:url");
+		return runPyIcebergWriter({
+			python: resolvePyIcebergPython(opts.python),
+			script: opts.writerScript ?? join(dirname(fileURLToPath(import.meta.url)), "..", "scripts", "iceberg-writer.py"),
+			job,
+			label: "iceberg overwrite subprocess",
+			processErrorAsParseFailure: true
+		});
+	};
+}
+function httpBackend(opts) {
+	const doFetch = opts.fetch ?? fetch;
+	return async (job) => {
+		const res = await doFetch(opts.endpoint, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				...opts.token ? { authorization: `Bearer ${opts.token}` } : {}
+			},
+			body: JSON.stringify(job)
+		});
+		if (!res.ok) {
+			const body = await res.text().catch(() => "");
+			return { error: `HTTP ${res.status}${body ? `: ${body}` : ""}` };
+		}
+		return await res.json();
+	};
+}
+function overwriteWriterAsSink(writer) {
+	return {
+		capabilities: {
+			canOverwrite: true,
+			appendOnly: false
+		},
+		emit: (slice, rows) => writer.overwriteSlice(slice, rows),
+		overwriteSlice: (slice, rows) => writer.overwriteSlice(slice, rows),
+		close: () => writer.close()
+	};
+}
+async function deleteSiteFromShard(args) {
+	const { catalog, backend, siteId, tables } = args;
+	const results = [];
+	for (const table of tables) {
+		const res = await backend({
+			op: "delete",
+			catalogUri: catalog.catalogUri,
+			namespace: catalog.namespace,
+			warehouse: catalog.warehouse,
+			s3: catalog.s3,
+			...catalog.catalogToken ? { catalogToken: catalog.catalogToken } : {},
+			table,
+			siteId
+		}).catch((err) => ({ error: err instanceof Error ? err.message : String(err) }));
+		results.push(res.error ? {
+			table,
+			error: res.error
+		} : {
+			table,
+			rowCount: res.rowCount
+		});
+	}
+	return results;
+}
+export { createIcebergOverwriteWriter, createLocalIcebergSink, deleteSiteFromShard, httpBackend, overwriteWriterAsSink, subprocessBackend };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/engine",
   "type": "module",
-  "version": "0.32.6",
+  "version": "0.32.8",
   "description": "Append-only Parquet/DuckDB storage engine + planner + adapters for the gscdump pipeline. Node + edge runtimes; opt-in heavy peers.",
   "author": {
     "name": "Harlan Wilton",
@@ -181,8 +181,8 @@
   "dependencies": {
     "drizzle-orm": "1.0.0-rc.3",
     "proper-lockfile": "^4.1.2",
-    "@gscdump/contracts": "0.32.6",
-    "gscdump": "0.32.6"
+    "gscdump": "0.32.8",
+    "@gscdump/contracts": "0.32.8"
   },
   "devDependencies": {
     "@duckdb/duckdb-wasm": "^1.32.0",