@mailwoman/soil 9.4.0 → 10.1.0

package/{lib/sdk → sdk}/cells.ts

@@ -3,31 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   The delineation-keyed cell index, and the two numbers the index resolution is chosen from.
- *
- *   THE CLASSIFIER ITSELF LIVES IN `@mailwoman/spatial`, because the traps it guards are properties of
- *   h3-js rather than of SSURGO: a centre-containment polyfill drops every polygon smaller than a cell, an
- *   exhausted WASM allocator reports success and returns zeros, and the allocator is sized from the
- *   bounding box. The layer contract states all three as requirements on every polygon builder. What is
- *   soil-shaped is the ACCUMULATOR below, which keys on the delineation rather than on a hazard class,
- *   because the reduction weights by the area a delineation covers.
- *
- *   EXPECT THE `partial` SHARE TO INVERT AGAINST THE FLOOD LAYER, AND DO NOT READ THAT AS A DEFECT. Flood
- *   polygons are large against their cells, so most cells fall wholly inside one zone and `compactCells`
- *   collapses long uniform interiors. Soil delineations are the opposite: 85.4% of `IA153`'s 17,966 of them
- *   are smaller than one resolution-9 cell, and the median is 24,863 m² against a 105,333 m² cell. Small
- *   polygons against large cells means most cells are crossed by a boundary — so the `partial` share should
- *   be HIGH, `compactCells` should yield close to nothing, and the index alone will rarely answer a point
- *   probe. That is not an argument against storing the geometry; it is the argument for why this layer
- *   carries the reduced `soil_capability_cell` alongside the index rather than relying on the index the way
- *   the flood layer can.
- *
- *   TWO NUMBERS GET REPORTED AT EACH CANDIDATE RESOLUTION, AND THEY MOVE IN OPPOSITE DIRECTIONS. The
- *   `partial` cell share says whether the containment index answers most probes alone. The share of cells
- *   whose top class holds less than half the cell says whether the layer is answering or hedging — the
- *   cell-grain analogue of NRCS's own `niccdcdpct` distribution, which reads 3.3% below half nationally.
- *   Going coarser improves the first and worsens the second, and picking between them is what the
- *   measurement is for.
+ *   The delineation-keyed cell index, plus the partial-cell and mixed-top-class shares that choose its resolution.
  */
 
 import {
@@ -41,7 +17,7 @@ import {
 import { getResolution } from "h3-js"
 
 /**
- * The label this layer's classifier failures carry.
+ * The label assigned to this layer's classifier failures.
  */
 export const SOIL_CELL_LABEL = "soil cells"
 
@@ -74,12 +50,13 @@ export interface SoilCellIndexMeasurement {
 	 */
 	partialCells: number
 	/**
-	 * `partialCells / touchedCells` — the share of in-layer probes that cannot be answered from the index alone.
+	 * `partialCells / touchedCells`, the share of in-layer probes that cannot
+	 * be answered using only the index.
 	 */
 	partialShare: number
 	/**
-	 * Whole cells after `compactCells`. Expected to be close to `wholeCells` here rather than far below it: compaction
-	 * needs a uniform interior, and small delineations do not produce one.
+	 * Whole cells after `compactCells`, expected to be close to `wholeCells` here
+	 * because small delineations do not produce a uniform interior.
 	 */
 	compactedWholeCells: number
 	/**
@@ -87,8 +64,8 @@ export interface SoilCellIndexMeasurement {
 	 */
 	cellDelineationPairs: number
 	/**
-	 * The mean number of delineations reaching a cell — the direct measure of how mixed a cell is before any rating is
-	 * read, and the number that rises as the resolution coarsens.
+	 * The mean number of delineations reaching a cell measures how mixed a cell is
+	 * before any rating is read and rises as the resolution coarsens.
 	 */
 	meanDelineationsPerCell: number
 	/**
@@ -102,10 +79,9 @@ export interface SoilCellIndexMeasurement {
 }
 
 /**
- * Accumulate one resolution's cell index over a stream of delineations.
- *
- * Held as short-cell STRINGS rather than the integers the tables store, because `compactCells` is an h3-js function
- * over full indexes and round-tripping through the integer form at every step would cost more than the strings do.
+ * Accumulates one resolution's cell index over a stream of delineations,
+ * held as short-cell strings because `compactCells` needs full h3-js indexes
+ * and round-tripping through the integer form would cost more.
  */
 export class SoilCellIndex {
 	readonly resolution: number
@@ -113,8 +89,8 @@ export class SoilCellIndex {
 	readonly #whole = new Set<string>()
 	readonly #touched = new Set<string>()
 	/**
-	 * `cell → delineation ids`. Every touched cell, so the mean below is over the real population rather than over the
-	 * fringe alone.
+	 * `cell → delineation ids` for every touched cell, so the mean is over the
+	 * real population rather than only the fringe.
 	 */
 	readonly #byCell = new Map<string, Set<string>>()
 
@@ -157,10 +133,8 @@ export class SoilCellIndex {
 	}
 
 	/**
-	 * Compact the whole-cell set and report the measurement.
-	 *
-	 * Compaction is applied to the WHOLE set only — a partial cell's parent is not partial in any useful sense, and
-	 * compacting it would claim the fringe covers ground it does not.
+	 * Compacts the whole-cell set and reports the measurement, applying compaction to the
+	 * whole set only because a partial cell's parent would claim fringe ground.
 	 */
 	finish(): SoilCellIndexMeasurement {
 		const compacted = compactAcrossResolutions(this.#whole)
@@ -196,8 +170,8 @@ export class SoilCellIndex {
 }
 
 /**
- * The measurement as markdown table ROWS — what a build receipt carries, one line per element so a caller printing them
- * never has to split a joined string back apart.
+ * The measurement as markdown table rows, one line per element so a caller never
+ * has to split a joined string back apart.
  */
 export function formatSoilResolutionRows(
 	measurements: ReadonlyArray<SoilCellIndexMeasurement & { mixedCellShare?: number }>

package/sdk/client.ts

@@ -0,0 +1,147 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ */
+
+import { APIClient, type APIClientConfig, type ClockLike, assertNoOGCServiceException } from "@mailwoman/core/api"
+import { buildDiskStorage } from "@mailwoman/core/api/disk-storage"
+import { parseJSONStrict, stringifyJSON } from "@mailwoman/core/json"
+import type { PathBuilderLike } from "path-ts"
+
+import { soilDatabasePath } from "#paths"
+import { saverestToISODate } from "#sdk/tabular"
+
+/**
+ * Sends anonymous requests to the Soil Data Access tabular query endpoint.
+ * Requests need no key or account.
+ */
+export const SDA_POST_REST_URL = "https://sdmdataaccess.nrcs.usda.gov/Tabular/post.rest"
+
+/**
+ * Sets the minimum spacing between Soil Data Access requests.
+ * NRCS publishes no rate limit for the service.
+ */
+export const SDA_MIN_REQUEST_INTERVAL_MS = 500
+
+const SDA_CACHE_TTL_MS = 12 * 60 * 60 * 1000
+
+/**
+ * One published survey area, as the catalogue reports it.
+ */
+export interface SurveyAreaCatalogEntry {
+	areasymbol: string
+	areaname: string
+
+	/**
+	 * The version-established date as an ISO date.
+	 * The survey area's archive filename embeds it.
+	 */
+	saverest: string
+	saversion: number
+}
+
+/**
+ * A client for Soil Data Access.
+ */
+export class SoilDataAccessClient extends APIClient<APIClientConfig> {
+	/**
+	 * Runs one SQL query and returns its rows as strings, with NULL as an empty string.
+	 *
+	 * @throws {OGCServiceError} When the service answers with an exception report,
+	 * including an HTTP 200 response.
+	 * A server-side timeout uses that status.
+	 */
+	public async query(sql: string): Promise<string[][]> {
+		const { data } = await this.fetch<string>({
+			method: "POST",
+			url: SDA_POST_REST_URL,
+
+			responseType: "text",
+			headers: { "Content-Type": "application/json" },
+			data: { SERVICE: "query", FORMAT: "JSON", QUERY: sql },
+		})
+
+		assertNoOGCServiceException(data, `soil data access (query: ${sql.slice(0, 200)})`)
+
+		const parsed = parseJSONStrict<{ Table?: unknown }>(data)
+
+		if (parsed.Table === undefined) return []
+
+		if (!Array.isArray(parsed.Table)) {
+			throw new TypeError(
+				`soil data access: the service answered with a Table that is not an array (${typeof parsed.Table}) — the response format changed`
+			)
+		}
+
+		return parsed.Table.map((row) => (row as unknown[]).map((value) => (value === null ? "" : String(value))))
+	}
+
+	/**
+	 * Returns the published survey areas whose symbol starts with `prefix`,
+	 * such as a state code or one whole area symbol.
+	 *
+	 * @throws {Error} When no survey area matches, because a build over an empty set
+	 * would otherwise report success having written no rows.
+	 */
+	public async readSurveyAreaCatalog(prefix: string): Promise<SurveyAreaCatalogEntry[]> {
+		const escaped = prefix.replaceAll("'", "''")
+
+		const rows = await this.query(
+			`SELECT areasymbol, areaname, saverest, saversion FROM sacatalog WHERE areasymbol LIKE '${escaped}%' ORDER BY areasymbol`
+		)
+
+		if (!rows.length) {
+			throw new Error(
+				`soil data access: the catalogue holds no survey area whose symbol starts with ${stringifyJSON(prefix)} — a build over an empty set would report success having written nothing`
+			)
+		}
+
+		return rows.map((row) => ({
+			areasymbol: row[0]!,
+			areaname: row[1]!,
+			saverest: saverestToISODate(row[2]!),
+			saversion: Number(row[3]),
+		}))
+	}
+
+	/**
+	 * Returns the map unit key the service's own geometry assigns at a point, or `undefined`,
+	 * as a cross-check against the authority through a channel this package never processed.
+	 */
+	public async mukeyAtPoint(latitude: number, longitude: number): Promise<string | undefined> {
+		const rows = await this.query(
+			`SELECT mukey FROM SDA_Get_Mukey_from_intersection_with_WktWgs84('point(${longitude} ${latitude})')`
+		)
+
+		return rows[0]?.[0] || undefined
+	}
+}
+
+/**
+ * Overrides the clock, the HTTP cache directory and the request spacing used
+ * by {@link createSoilDataAccessClient}.
+ */
+export interface CreateSoilDataAccessClientOptions {
+	clock?: ClockLike
+	cacheDirectory?: PathBuilderLike
+	minRequestIntervalMs?: number
+}
+
+/**
+ * Creates a {@link SoilDataAccessClient} with retries, a 12-hour disk cache and the default request pacing.
+ */
+export function createSoilDataAccessClient(options: CreateSoilDataAccessClientOptions = {}): SoilDataAccessClient {
+	return new SoilDataAccessClient({
+		displayName: "SoilDataAccess",
+		minRequestIntervalMs: options.minRequestIntervalMs ?? SDA_MIN_REQUEST_INTERVAL_MS,
+		retry: true,
+		...(options.clock ? { clock: options.clock } : {}),
+		caching: {
+			ttl: SDA_CACHE_TTL_MS,
+			storage: buildDiskStorage({
+				directory: (options.cacheDirectory ?? soilDatabasePath("cache", "http")).toString(),
+			}),
+		},
+	})
+}

package/sdk/download.ts

@@ -0,0 +1,131 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ */
+
+import { tryStat } from "@mailwoman/core/fs/readers"
+import { makeDirectories } from "@mailwoman/core/fs/writers"
+import { runFile } from "@mailwoman/core/process"
+import { streamToDisk } from "@mailwoman/core/utils"
+import { PathBuilder, type PathBuilderLike } from "path-ts"
+
+/**
+ * Points to the Web Soil Survey download cache that serves survey-area archives.
+ */
+export const WSS_SSA_CACHE_URL = "https://websoilsurvey.sc.egov.usda.gov/DSD/Download/Cache/SSA"
+
+/**
+ * Returns the archive URL for one survey area at one version date, with the brackets
+ * around the date percent-encoded because they are not valid in a URL path.
+ */
+export function surveyAreaArchiveURL(areaSymbol: string, versionDate: string): string {
+	return `${WSS_SSA_CACHE_URL}/wss_SSA_${areaSymbol}_%5B${versionDate}%5D.zip`
+}
+
+/**
+ * Configures {@link downloadSurveyArea}, which caches the archive and its
+ * extracted tree under `cacheRoot/<versionDate>`.
+ */
+export interface DownloadSurveyAreaOptions {
+	areaSymbol: string
+
+	/**
+	 * The survey area's version date from `sacatalog.saverest`, formatted as `YYYY-MM-DD`.
+	 */
+	versionDate: string
+
+	/**
+	 * The cache directory, where each version date gets its own subdirectory so a new
+	 * vintage never overwrites an old one and a repeat run downloads no file.
+	 */
+	cacheRoot: PathBuilderLike
+	onProgress?: (message: string) => void
+}
+
+const PROGRESS_STRIDE_BYTES = 8 * 1024 * 1024
+
+const UNKNOWN_VERSION_STATUS = 400
+
+/**
+ * What one acquired survey area is, on disk.
+ */
+export interface SurveyAreaArchive {
+	areaSymbol: string
+	versionDate: string
+
+	/**
+	 * The extracted `<areasymbol>/` directory.
+	 * It contains `spatial/` and `tabular/`.
+	 */
+	root: PathBuilder
+	spatialDirectory: PathBuilder
+	tabularDirectory: PathBuilder
+
+	/**
+	 * The downloaded ZIP archive, kept so a repeat run skips the transfer and the bytes can be rechecked.
+	 */
+	archivePath: PathBuilder
+}
+
+/**
+ * Downloads and unzips one survey area into the cache, skipping completed steps.
+ * Returns the paths to its files.
+ *
+ * The download goes through a `.part` file so an interrupted transfer never looks like a complete archive.
+ *
+ * @throws {Error} When the host answers anything but 200, or when the extracted
+ * tree lacks the `spatial` or `tabular` directory.
+ */
+export async function downloadSurveyArea(options: DownloadSurveyAreaOptions): Promise<SurveyAreaArchive> {
+	const vintageDirectory = PathBuilder.from(options.cacheRoot)(options.versionDate)
+	const root = vintageDirectory(options.areaSymbol)
+	const archivePath = vintageDirectory(`wss_SSA_${options.areaSymbol}.zip`)
+
+	if (!(await tryStat(root))) {
+		await makeDirectories(vintageDirectory)
+
+		if (await tryStat(archivePath)) {
+			options.onProgress?.(`${options.areaSymbol}: archive for ${options.versionDate} already downloaded`)
+		} else {
+			await streamToDisk({
+				url: surveyAreaArchiveURL(options.areaSymbol, options.versionDate),
+				destination: archivePath,
+				context: "soil download",
+				progressStrideBytes: PROGRESS_STRIDE_BYTES,
+				describeStatus: (status) =>
+					status === UNKNOWN_VERSION_STATUS
+						? " — this host answers 400 rather than 404 for a version date it does not hold, so check the date against sacatalog.saverest"
+						: undefined,
+
+				...(options.onProgress
+					? { onProgress: (message: string) => options.onProgress?.(`${options.areaSymbol}: ${message}`) }
+					: {}),
+			})
+		}
+
+		await runFile("unzip", ["-o", "-q", archivePath, "-d", vintageDirectory])
+	} else {
+		options.onProgress?.(`${options.areaSymbol}: already extracted for ${options.versionDate}`)
+	}
+
+	const spatialDirectory = root("spatial")
+	const tabularDirectory = root("tabular")
+
+	for (const directory of [spatialDirectory, tabularDirectory]) {
+		if (!(await tryStat(directory))) {
+			throw new Error(
+				`soil download: ${options.areaSymbol} extracted without a ${directory} directory — every survey area publishes both spatial/ and tabular/, so this archive is not the product`
+			)
+		}
+	}
+
+	return {
+		areaSymbol: options.areaSymbol,
+		versionDate: options.versionDate,
+		root,
+		spatialDirectory,
+		tabularDirectory,
+		archivePath,
+	}
+}

package/{lib/sdk/ingest-chunk.ts → sdk/ingest/chunk.ts}

@@ -3,21 +3,18 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   The streaming pass — every delineation into `soil_map_unit_area` and into the build's touch table — as a
- *   unit of work that can run over PART of one survey area.
+ *   This streaming pass writes each delineation to `soil_map_unit_area` and the build's touch table.
+ *   It can process part of one survey area as a unit of work.
  *
- *   WHY THIS IS A CHUNK RATHER THAN A WHOLE FILE. h3's WASM heap cannot be reset from JavaScript, and it does
- *   not survive an unbounded number of polyfill calls: over the flood layer's real product, runs died after
- *   roughly 510,000 and 798,000 features on geometry that classifies in milliseconds in a fresh process. A
- *   build that completes only when fragmentation happens to stay low is not a reproducible build, so the
- *   classification is bounded by construction — {@linkcode buildSoilDatabase} runs one of these per range of
- *   the shapefile's own FIDs, each in its own process, and each therefore against a heap that starts empty.
- *   Iowa's 99 survey areas hold far more delineations together than any one of them does, which is why the
- *   bound is per RANGE rather than per area.
+ *   H3's wasm heap cannot be reset from JavaScript. It also cannot sustain unlimited polyfill calls.
+ *   Two runs over the flood layer's real product stopped after roughly 510,000 and 798,000 features.
+ *   The same geometries classify in milliseconds in a fresh process. A build that completes only when
+ *   fragmentation stays low is not reproducible. {@linkcode buildSoilDatabase} bounds each process to a range
+ *   of the shapefile's FIDs. Each range gets a separate process with a fresh heap. Iowa's 99 survey areas
+ *   contain far more delineations together than each area contains by itself. The bound therefore applies per range.
  *
- *   THE CHUNK OWNS NO ARTIFACT. It appends rows to a database the parent created and will seal, and returns
- *   counts the parent adds up. Chunks run one at a time against that file, so there is no concurrent writer
- *   and no locking to reason about.
+ *   The chunk appends rows to a database created by the parent. The parent seals that database and adds up
+ *   the counts returned by each chunk. Chunks run one at a time against the file, so only one writer uses it.
  */
 
 import { addCoverageCells, encodeRings, ringAreaReadings, ringsBoundingBox, shortCellToInt } from "@mailwoman/spatial"
@@ -29,8 +26,12 @@ import { classifyDelineationCells } from "#sdk/cells"
 import type { SoilFeatureSource } from "#sdk/ingest"
 
 /**
- * Rows per bulk-insert transaction. Chosen for the geometry table, whose rows carry a blob: a larger transaction grows
- * the write-ahead file without improving throughput.
+ * Rows per bulk-insert transaction.
+ *
+ * Chosen for the geometry table.
+ * Each row contains a blob.
+ *
+ * A larger transaction grows the write-ahead file without improving throughput.
  */
 const INSERT_TRANSACTION_ROWS = 5000
 
@@ -40,8 +41,9 @@ const INSERT_TRANSACTION_ROWS = 5000
 const PROGRESS_STRIDE = 20_000
 
 /**
- * What one chunk produced. Every field is JSON-serializable, because a chunk normally reports across a process
- * boundary.
+ * What one chunk produced.
+ *
+ * Every field is JSON-serializable, because a chunk normally reports across a process boundary.
  */
 export interface SoilChunkResult {
 	areaSymbol: string
@@ -51,19 +53,22 @@ export interface SoilChunkResult {
 	 */
 	coarsened: number
 	/**
-	 * `[coverageCell, delineationsReachingIt]` pairs — an array rather than a `Map` so it survives the process boundary.
+	 * `[coverageCell, delineationsReachingIt]` pairs — an array rather than a `Map`
+	 * so it survives the process boundary.
 	 */
 	observedByCoverageCell: Array<[number, number]>
 	/**
-	 * The same, counting only delineations whose map unit HAS soil mapping behind it.
+	 * The same, counting only delineations whose map unit has soil mapping behind it.
 	 *
-	 * Separate from the total because the coverage rule turns on it: a coverage cell reached only by `NOTCOM` and
-	 * access-denied polygons is inside a published survey area and carries no digitized soil mapping, and the survey's
-	 * §3.2 gives it no row.
+	 * Separate from the total because the coverage rule depends on this value.
+	 * A cell reached only by `notcom` or access-denied polygons lies inside a published
+	 * survey area and contains no digitized soil mapping.
+	 *
+	 * Section 3.2 of the survey specification assigns no row to that cell.
 	 */
 	mappedByCoverageCell: Array<[number, number]>
 	/**
-	 * Square metres: the encoded rings read WITH their holes, and read without.
+	 * Square meters computed from the encoded rings, with holes and with every ring treated as exterior.
 	 */
 	area: { nestedM2: number; allExteriorM2: number }
 }
@@ -73,8 +78,10 @@ export interface IngestSoilChunkOptions {
 	indexResolution: number
 	coverageResolution: number
 	/**
-	 * The map units with NO soil mapping behind them — `NOTCOM`, `NOTPUB`, access denied, or no readable component
-	 * weights. Passed in rather than joined here so the chunk stays a streaming pass over geometry.
+	 * The map units with no soil mapping behind them — `notcom`, `notpub`,
+	 * access denied, or no readable component weights.
+	 *
+	 * Passed in rather than joined here so the chunk stays a streaming pass over geometry.
 	 */
 	noMappingMukeys: ReadonlySet<string>
 	onProgress?: (message: string) => void
@@ -83,7 +90,8 @@ export interface IngestSoilChunkOptions {
 /**
  * Stream one chunk of one survey area into `database`.
  *
- * @throws {Error} On a delineation the classifier refuses — which includes the allocator's silent zero-cell answer.
+ * @throws {Error} On a delineation the classifier refuses — which includes the
+ * allocator's silent zero-cell answer.
  */
 export async function ingestSoilChunk(
 	database: DatabaseClient<SoilDatabase>,

package/{lib/scripts/ingest-chunk.ts → sdk/ingest/worker.ts}

@@ -3,9 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   One chunk of the soil ingest, as its own process — spawned by `buildSoilDatabase`, never run by hand.
- *   The process boundary and the stdout contract live with `runIngestChunkScript`; what stays here is only
- *   this product's flags and its feature-source constructor.
+ *   One chunk of the soil ingest as its own process, spawned by `buildSoilDatabase` and never run by hand.
  */
 
 import { requiredArgument } from "@mailwoman/core/scripting/arguments"
@@ -14,7 +12,7 @@ import type { DatabaseClient } from "@mailwoman/sqlite/client"
 
 import type { SoilDatabase } from "#schema"
 import { createShapefileFeatureSource } from "#sdk/ingest"
-import { ingestSoilChunk } from "#sdk/ingest-chunk"
+import { ingestSoilChunk } from "#sdk/ingest/chunk"
 
 await runIngestChunkScript({
 	context: "soil ingest-chunk",
@@ -33,15 +31,18 @@ await runIngestChunkScript({
 				areaSymbol: requiredArgument("soil ingest-chunk", "area-symbol", values["area-symbol"]),
 				fidFrom: Number(requiredArgument("soil ingest-chunk", "fid-from", values["fid-from"])),
 				fidTo: Number(requiredArgument("soil ingest-chunk", "fid-to", values["fid-to"])),
-				// A range's own count is not knowable up front — `ogrinfo` reports the layer's total and nothing narrower — so
-				// the chunk asserts nothing about its size and the PARENT checks the per-area sum against the shapefile's.
+				// A range's own count is not knowable up front — `ogrinfo` reports the layer's total
+				// and no narrower count — so the chunk makes no assertion about its size
+				// and the parent checks the per-area sum against the shapefile's.
 				declaredFeatureCount: 0,
 			}),
 			indexResolution: chunk.indexResolution,
 			coverageResolution: chunk.coverageResolution,
-			// An empty string is an empty set, not "every map unit": a build where nothing lacks soil mapping passes one, and
-			// `"".split(",")` yields one empty element that has to be dropped rather than joined against as a mukey.
-			noMappingMukeys: new Set((values["no-mapping-mukeys"] ?? "").split(",").filter((mukey) => mukey.length > 0)),
+			// An empty string is an empty set rather than "every map unit": a build
+			// where every map unit has soil mapping passes one.
+			// `"".split(",")` yields one empty element that has to be dropped
+			// rather than joined against as a mukey.
+			noMappingMukeys: new Set((values["no-mapping-mukeys"] ?? "").split(",").filter((mukey) => mukey.length)),
 			onProgress: chunk.onProgress,
 		}),
 })