@mailwoman/soil 9.4.0 → 10.1.0

package/lib/sdk/ingest.ts

@@ -1,278 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- *   Read a survey area's published shapefiles as a stream of WGS84 delineations, through ogr2ogr.
- *
- *   OGR IS BUILD TOOLING, NEVER A SERVE DEPENDENCY (SCOPE invariant 6). It converts the authority's geometry
- *   into the structure the runtime probes, and nothing downstream of this module knows GDAL exists.
- *
- *   THE SOURCE IS ALREADY IN WGS84, AND CHECKING IT IS STILL THE CHECK. Each `.prj` is an ESRI WKT reading
- *   `GEOGCS["GCS_WGS_1984",…]`, which GDAL resolves to EPSG:4326 — so no reprojection is needed before H3.
- *   The authority code is asserted anyway before a single feature is read, and the reprojected stream is
- *   asserted against the layer's own declared extent, which is the check that catches a coordinate-order
- *   mistake the projection check cannot see.
- *
- *   THE DATUM GUARD RUNS EVEN THOUGH THE ANSWER IS THE IDENTITY, AND THAT IS THE POINT. PROJ substitutes a
- *   ballpark datum shift SILENTLY when the accurate grid is missing — measured on the flood layer at 3.4 m
- *   over an entire country, visible only as eight disagreements out of 59 against the authority's own
- *   service. For an EPSG:4326 source `projinfo` answers `Null geographic offset from WGS 84 to WGS 84, 0 m,
- *   World.` and the guard passes in one process. Skipping it on the reasoning that this source needs no
- *   shift is how the guard comes to be missing on the day a source arrives that does.
- *
- *   THE ID IS THE SHAPEFILE'S OWN FID, AND IT HAS TO BE, because SSURGO publishes no per-delineation key:
- *   `MUKEY` names the MAP UNIT and one map unit has many delineations — `IA153` holds 17,966 delineations
- *   across 152 map units. So `area_id` is `<areasymbol>:<fid>`, which is stable across runs and is what makes
- *   a bounded chunk name the same features every time.
- */
-
-import { declaredFeatureCount } from "@mailwoman/core/layers"
-import { assertRingsInsideExtent, requireArealPolygons, type MultiPolygonRings } from "@mailwoman/spatial"
-import { readOGRLayerIdentity } from "@mailwoman/spatial/tools/ogr"
-import { ogr2ogrGeoJSONSeq } from "@mailwoman/spatial/tools/ogr-stream"
-import { basename, join } from "path-ts"
-
-import { SSURGO_SOURCE_EPSG } from "#vocabulary"
-
-/**
- * Coordinate decimals ogr2ogr writes into the stream. Nine is well past the source's own precision — the metadata
- * states compilation to base maps meeting National Map Accuracy Standards at 1 inch = 1,000 feet — and is chosen so the
- * round trip contributes nothing measurable to the area cross-check.
- */
-const COORDINATE_PRECISION = 9
-
-/**
- * How far outside the layer's declared extent a vertex may fall before the ingest refuses.
- *
- * A tenth of a degree is about 11 km — small enough that an unprojected or axis-swapped read, which lands whole
- * hemispheres away, still fails, and loose enough that a rounded declared extent is not brittle.
- */
-const BBOX_MARGIN_DEGREES = 0.1
-
-/**
- * The shapefile holding a survey area's map-unit polygons — the delineations this layer stores.
- */
-export function mapUnitShapefile(spatialDirectory: string, areaSymbol: string): string {
-	return join(spatialDirectory, `soilmu_a_${areaSymbol.toLowerCase()}.shp`)
-}
-
-/**
- * The shapefile holding a survey area's own OUTLINE. The footprint comes from HERE and never from the union of the
- * rated polygons — `NOTCOM` and access-denied map units are inside the footprint and carry no rating, so a footprint
- * derived from the rated set would report them as unmapped when the authority has declared exactly what they are.
- */
-export function surveyAreaShapefile(spatialDirectory: string, areaSymbol: string): string {
-	return join(spatialDirectory, `soilsa_a_${areaSymbol.toLowerCase()}.shp`)
-}
-
-/**
- * One map-unit delineation, reprojected to WGS84.
- */
-export interface SoilDelineation {
-	/**
-	 * `<areasymbol>:<fid>`.
-	 */
-	areaID: string
-	mukey: string
-	areasymbol: string
-	polygons: MultiPolygonRings
-}
-
-/**
- * What a shapefile says about itself, read before any feature is.
- */
-export interface SoilSourceIdentity {
-	epsg: number
-	featureCount: number
-	layer: string
-	/**
-	 * The layer's own declared extent, `[minLon, minLat, maxLon, maxLat]`.
-	 */
-	bbox: readonly [number, number, number, number]
-}
-
-export interface SoilIngestOptions {
-	shapefilePath: string
-	/**
-	 * Layer inside it. Defaults to the shapefile's base name, which is what the ESRI driver reports.
-	 */
-	layer?: string
-	/**
-	 * The EPSG code the source must declare.
-	 */
-	expectEPSG?: number
-	/**
-	 * Read only the shapefile's own FIDs in `[fidFrom, fidTo]`, inclusive — what makes a bounded chunk possible.
-	 */
-	fidFrom?: number
-	fidTo?: number
-	/**
-	 * Stop after this many features. The fixture and smoke rungs use it; a full build does not set it.
-	 */
-	limit?: number
-}
-
-/**
- * Read what the shapefile declares about itself, and refuse a projection this ingest was not written for.
- *
- * @throws {Error} When the layer is missing, declares no EPSG authority code, declares one other than `expectEPSG`, or
- *   reports no feature count.
- */
-export async function readSoilSourceIdentity(options: SoilIngestOptions): Promise<SoilSourceIdentity> {
-	const identity = await readOGRLayerIdentity({
-		path: options.shapefilePath,
-		layer: options.layer ?? basename(options.shapefilePath, ".shp"),
-		expectEPSG: options.expectEPSG ?? SSURGO_SOURCE_EPSG,
-		context: "soil ingest",
-		requireExtent: true,
-		messages: {
-			noAuthorityCode: "the projection cannot be checked, and reading one datum's coordinates as another's is silent",
-			epsgMismatch:
-				"SSURGO publishes geographic WGS84, so a different code is a product change rather than a variation to absorb",
-		},
-	})
-
-	return { epsg: identity.epsg, featureCount: identity.featureCount, layer: identity.layer, bbox: identity.extent! }
-}
-
-/**
- * The ingest's `SELECT`, with the FID range applied when one is asked for.
- */
-function delineationSelectSQL(layer: string, options: SoilIngestOptions): string {
-	const select = `SELECT FID AS fid, MUKEY AS mukey, AREASYMBOL AS areasymbol FROM "${layer}"`
-	const bounds: string[] = []
-
-	if (options.fidFrom !== undefined) {
-		bounds.push(`FID >= ${options.fidFrom}`)
-	}
-
-	if (options.fidTo !== undefined) {
-		bounds.push(`FID <= ${options.fidTo}`)
-	}
-
-	return bounds.length ? `${select} WHERE ${bounds.join(" AND ")}` : select
-}
-
-interface RawFeature {
-	properties: { fid: number | string; mukey: number | string | null; areasymbol: string | null }
-	geometry: { type: string; coordinates: unknown } | null
-}
-
-/**
- * Stream the map-unit delineations as WGS84 features.
- *
- * Every feature is checked against the declared extent as it passes. A swapped coordinate order survives a projection
- * check — both axes are still numbers in a plausible range — and shows up here immediately.
- *
- * @throws {Error} When ogr2ogr fails, when a feature carries no geometry or no `MUKEY`, or when a vertex falls outside
- *   the declared extent.
- */
-export async function* readSoilDelineations(
-	options: SoilIngestOptions & { bbox: readonly [number, number, number, number] }
-): AsyncGenerator<SoilDelineation> {
-	const layer = options.layer ?? basename(options.shapefilePath, ".shp")
-	const [minLon, minLat, maxLon, maxLat] = options.bbox
-
-	const args = [
-		"-f",
-		"GeoJSONSeq",
-		"/vsistdout/",
-		// The OUTPUT projection. `expectEPSG` is the assertion `readSoilSourceIdentity` makes about the SOURCE and is not
-		// the same thing: the consumer reads WGS84, whatever the shapefile declares.
-		"-t_srs",
-		"EPSG:4326",
-		"-lco",
-		`COORDINATE_PRECISION=${COORDINATE_PRECISION}`,
-		...(options.limit === undefined ? [] : ["-limit", String(options.limit)]),
-		"-sql",
-		delineationSelectSQL(layer, options),
-		options.shapefilePath,
-	]
-
-	for await (const raw of ogr2ogrGeoJSONSeq<RawFeature>(args, "soil ingest")) {
-		yield toDelineation(raw, { minLon, minLat, maxLon, maxLat })
-	}
-}
-
-/**
- * Validate one raw GeoJSON feature and narrow it. Split out so the generator body stays a loop.
- */
-function toDelineation(
-	raw: RawFeature,
-	extent: { minLon: number; minLat: number; maxLon: number; maxLat: number }
-): SoilDelineation {
-	const { properties, geometry } = raw
-
-	if (!geometry) {
-		throw new Error(`soil ingest: delineation ${properties.fid} carries no geometry`)
-	}
-
-	if (properties.mukey === null || properties.mukey === "") {
-		throw new Error(
-			`soil ingest: delineation ${properties.fid} carries no MUKEY — a delineation with no map unit joins to nothing and would read downstream as unmapped ground`
-		)
-	}
-
-	if (!properties.areasymbol) {
-		throw new Error(`soil ingest: delineation ${properties.fid} carries no AREASYMBOL`)
-	}
-
-	const polygons = requireArealPolygons(geometry, `delineation ${properties.fid}`, "soil ingest")
-
-	assertRingsInsideExtent(polygons, `delineation ${properties.fid}`, extent, BBOX_MARGIN_DEGREES, "soil ingest")
-
-	return {
-		areaID: `${properties.areasymbol}:${properties.fid}`,
-		mukey: String(properties.mukey),
-		areasymbol: properties.areasymbol,
-		polygons,
-	}
-}
-
-/**
- * Where a build's delineations come from, and what the source declares about itself.
- *
- * The builder takes ONE of these rather than a path, which is what makes the fixture rung possible: hand-built geometry
- * with no network and no GDAL still exercises the whole database half — the domain check, the cell classification, the
- * reduction, the coverage rows, the manifest and the seal.
- */
-export interface SoilFeatureSource {
-	areaSymbol: string
-	/**
-	 * What the source says it holds. The build compares its own streamed total against this, so a short read throws
-	 * instead of building a smaller county.
-	 */
-	declaredFeatureCount: number
-	layer: string
-	epsg: number
-	/**
-	 * A description of where these delineations came from, for the receipt.
-	 */
-	origin: string
-	delineations: () => AsyncIterable<SoilDelineation>
-}
-
-/**
- * One survey area's map-unit shapefile as a feature source — identity read up front, features streamed on demand.
- */
-export async function createShapefileFeatureSource(
-	options: SoilIngestOptions & { areaSymbol: string; declaredFeatureCount?: number }
-): Promise<SoilFeatureSource> {
-	const identity = await readSoilSourceIdentity(options)
-
-	return {
-		areaSymbol: options.areaSymbol,
-		// A RANGE's own count is supplied by the caller, because `ogrinfo` reports the layer's total and nothing narrower.
-		// The whole-file total is still checked: the builder sums what its chunks streamed and compares that.
-		declaredFeatureCount: declaredFeatureCount({
-			declared: options.declaredFeatureCount,
-			limit: options.limit,
-			layerCount: identity.featureCount,
-		}),
-		layer: identity.layer,
-		epsg: identity.epsg,
-		origin: options.shapefilePath,
-		delineations: () => readSoilDelineations({ ...options, bbox: identity.bbox }),
-	}
-}

package/lib/sdk/reduce.ts

@@ -1,375 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- *   The reduction: the containment index, read once, into one per-cell distribution both consumers share.
- *
- *   A DISTRIBUTION, NEVER A WINNER, AND THAT IS FORCED BY MEASUREMENT. 84.0% of the 339,191 national map
- *   units hold two or more components; in 16.8% the largest component covers under half the map unit; and
- *   85.4% of `IA153`'s delineations are smaller than one resolution-9 cell. No affordable cell size removes
- *   the mixture — it is a property of the survey, whose own `mukind` says so: 128,499 map units (38.0%) are
- *   complexes, associations or undifferentiated groups, which is NRCS stating that the soils are
- *   intermingled and cannot be separated at the mapping scale. A winner class would satisfy the result-level
- *   consumer and starve the signal consumer, which needs a magnitude to vary over.
- *
- *   THE WEIGHT IS A UNIFORM-AREA LATTICE OVER THE CELL, AND THE GRAIN IS CHOSEN AGAINST THE AUTHORITY'S OWN.
- *   A cell's children at {@link WEIGHT_LATTICE_DEPTH} levels finer have equal area by construction, so
- *   counting which delineation covers each child centre estimates covered area without a polygon clip. At
- *   depth 2 that is 49 children — 2.04% per child, which is the finest share NRCS's own
- *   `muaggatt.niccdcdpct` ever reports (observed minimum: 2%). Resolving finer than the authority publishes
- *   would be precision this layer cannot source.
- *
- *   A WHOLE CELL SKIPS THE LATTICE ENTIRELY, and that is exact rather than an optimization: a cell lying
- *   wholly inside one delineation is covered by that delineation and by nothing else, so its distribution is
- *   that map unit's component split and its `mapped_share` is 1.
- *
- *   `mapped_share` EXISTS BECAUSE A SURVEY-AREA EDGE CELL IS PARTLY OUTSIDE EVERY DELINEATION. Without it,
- *   the unmapped remainder would silently deflate every class share — an absence represented as a small
- *   number, which is the one thing this schema exists to prevent. The five shares are normalized over the
- *   mapped part, so they sum to 1 exactly, and `mapped_share` says how much of the cell that was.
- *
- *   CLASS 8 IS A CLASS SHARE, NOT AN ABSENCE. It is a determination — the survey looked and rated the land
- *   as precluding commercial plant production, and 67,547 national components carry it. Folding it in with
- *   `NOTCOM`, a water body and an unrated series would produce a well-formed wrong answer, and separating
- *   the four absences from the one positive negative is the whole reason this table has five columns rather
- *   than one.
- */
-
-import { parseJSONStrict } from "@mailwoman/core/json"
-import { pointInEncodedRings, type H3Cell } from "@mailwoman/spatial"
-import { cellToChildren, cellToLatLng } from "h3-js"
-
-import type { SoilCapabilityCellTable, SoilComponentTable, SoilMapUnitTable } from "#schema"
-import { SOIL_SHARE_WEIGHTING } from "#vocabulary"
-
-/**
- * How many resolution levels finer than the index the weighting lattice runs.
- *
- * Two, giving 49 children per cell and a 2.04% share granularity. That is deliberately matched to the finest share the
- * authority itself publishes — `muaggatt.niccdcdpct`'s observed minimum is 2% — because a lattice finer than the
- * source's own reporting grain buys precision this layer cannot source, at 7× the cost per level.
- */
-export const WEIGHT_LATTICE_DEPTH = 2
-
-/**
- * Class shares below this are folded into `other_share` rather than stored.
- *
- * One percent, which sits BELOW the lattice's own 2.04% granularity, so nothing a single child cell produces is
- * truncated — what lands here is the long tail that component percentages create inside a child (a 1%-weight component
- * inside one child cell contributes 0.02%). Truncating a long tail is legitimate; doing it silently is not, which is
- * why the remainder is stored explicitly and the shares still sum to 1.
- */
-export const CLASS_SHARE_FLOOR = 0.01
-
-/**
- * One delineation reaching a cell, as the reduction needs it.
- */
-export interface CellCandidate {
-	areaID: string
-	mukey: string
-	containment: string
-	minLat: number
-	minLon: number
-	maxLat: number
-	maxLon: number
-	rings: Uint8Array
-}
-
-/**
- * What a map unit contributes per unit of area — computed once per map unit and reused for every cell it reaches.
- */
-export interface MapUnitProfile {
-	/**
-	 * Class code → share of the map unit, summing to 1 across classes and the three mapped-absence buckets.
-	 */
-	classShares: ReadonlyMap<string, number>
-	unrated: number
-	notRateable: number
-	noData: number
-}
-
-/**
- * Turn one map unit and its components into the per-unit-area profile the reduction folds in.
- *
- * A `no_mapping` map unit contributes wholly to `nodata` and NEVER to a class: it is a polygon the authority drew with
- * no soil mapping behind it, and reading it as a low class would be the reassuring wrong number §3.2 of the survey is
- * about.
- *
- * The split across components is by `comppct_r`, the component's representative percentage of its map unit, normalized
- * by the total actually present rather than assumed to be 100 — measured on `IA153` all 152 map units sum to exactly
- * 100, and a national build must not depend on that holding everywhere.
- */
-export function mapUnitProfile(
-	mapUnit: Pick<SoilMapUnitTable, "no_mapping">,
-	components: ReadonlyArray<Pick<SoilComponentTable, "comppct_r" | "compkind" | "nirrcapcl">>
-): MapUnitProfile {
-	if (mapUnit.no_mapping) {
-		return { classShares: new Map(), unrated: 0, notRateable: 0, noData: 1 }
-	}
-
-	let total = 0
-
-	for (const component of components) {
-		total += component.comppct_r
-	}
-
-	// A map unit whose components carry no weight at all publishes no readable proportion, so nothing can be apportioned
-	// from it. It is marked `no_mapping` upstream for exactly this reason; reaching here with a zero total means the
-	// upstream check and this one disagree, and answering with an empty distribution would silently drop the delineation's
-	// area out of every share.
-	if (total <= 0) {
-		return { classShares: new Map(), unrated: 0, notRateable: 0, noData: 1 }
-	}
-
-	const classShares = new Map<string, number>()
-
-	let unrated = 0
-	let notRateable = 0
-
-	for (const component of components) {
-		const weight = component.comppct_r / total
-
-		if (weight <= 0) continue
-
-		if (component.nirrcapcl) {
-			classShares.set(component.nirrcapcl, (classShares.get(component.nirrcapcl) ?? 0) + weight)
-
-			continue
-		}
-
-		// A NULL rating means the survey did not rate this component, and WHY it did not is what separates the two buckets.
-		// A miscellaneous area is a non-soil area — rock outcrop, water — that the capability rating does not apply to; a
-		// named soil with no rating is one the survey chose not to rate. Read as one number they would both say "not
-		// arable", which neither of them says.
-		if (component.compkind === "Miscellaneous area") {
-			notRateable += weight
-		} else {
-			unrated += weight
-		}
-	}
-
-	return { classShares, unrated, notRateable, noData: 0 }
-}
-
-/**
- * What one cell's reduction produced, plus the diagnostics the receipt reports.
- */
-export interface ReducedCell {
-	row: SoilCapabilityCellTable
-	/**
-	 * True when the top class covers less than half the cell — the §4.7 number, counted here so it comes off the artifact
-	 * rather than out of a separate harness.
-	 */
-	topClassUnderHalf: boolean
-	/**
-	 * True when the lattice was used rather than the whole-cell fast path.
-	 */
-	sampled: boolean
-}
-
-/**
- * Reduce one cell.
- *
- * @throws {Error} When a candidate names a map unit the profile map does not hold. A missing profile means the
- *   attribute join is short, and answering with the remaining candidates would report a well-formed distribution over
- *   part of the cell.
- */
-export function reduceCell(
-	cell: H3Cell,
-	resolution: number,
-	candidates: ReadonlyArray<CellCandidate>,
-	profiles: ReadonlyMap<string, MapUnitProfile>,
-	h3Cell: number
-): ReducedCell {
-	const weights = new Map<string, number>()
-	let sampled = false
-	let mappedShare = 1
-
-	const whole = candidates.length === 1 ? candidates.find((candidate) => candidate.containment === "whole") : undefined
-
-	if (whole) {
-		// Exactly one delineation, and it covers the cell entirely. Nothing else can reach it, so the lattice would return
-		// the same answer at 49 times the cost.
-		weights.set(whole.mukey, 1)
-	} else {
-		sampled = true
-
-		const children = cellToChildren(cell, resolution + WEIGHT_LATTICE_DEPTH)
-		let covered = 0
-
-		for (const child of children) {
-			const [latitude, longitude] = cellToLatLng(child)
-			const owner = candidateAt(candidates, latitude, longitude)
-
-			if (!owner) continue
-
-			covered++
-			weights.set(owner.mukey, (weights.get(owner.mukey) ?? 0) + 1)
-		}
-
-		if (!covered) {
-			// Every child centre fell outside every delineation reaching the cell. The cell IS touched — the index says so —
-			// but no lattice point landed inside, which happens when a sliver clips a corner. Reporting shares over nothing
-			// would divide by zero; reporting a mapped share of zero is the truthful answer, and the row is dropped by the
-			// caller rather than stored as an all-zero distribution.
-			return {
-				row: emptyRow(h3Cell, candidates.length),
-				topClassUnderHalf: false,
-				sampled,
-			}
-		}
-
-		mappedShare = covered / children.length
-
-		for (const [mukey, count] of weights) {
-			weights.set(mukey, count / covered)
-		}
-	}
-
-	return assembleRow(h3Cell, weights, profiles, mappedShare, candidates.length, sampled)
-}
-
-/**
- * The delineation covering a point, or `undefined` where none does.
- *
- * The bounding box is the prefilter the geometry table stores precisely so the ray cast runs on the few delineations
- * that could contain the point rather than on every delineation reaching the cell.
- */
-function candidateAt(
-	candidates: ReadonlyArray<CellCandidate>,
-	latitude: number,
-	longitude: number
-): CellCandidate | undefined {
-	for (const candidate of candidates) {
-		if (
-			longitude < candidate.minLon ||
-			longitude > candidate.maxLon ||
-			latitude < candidate.minLat ||
-			latitude > candidate.maxLat
-		) {
-			continue
-		}
-
-		if (pointInEncodedRings(candidate.rings, longitude, latitude)) return candidate
-	}
-
-	return undefined
-}
-
-/**
- * Fold the per-map-unit weights through their profiles into the stored row.
- */
-function assembleRow(
-	h3Cell: number,
-	weights: ReadonlyMap<string, number>,
-	profiles: ReadonlyMap<string, MapUnitProfile>,
-	mappedShare: number,
-	delineations: number,
-	sampled: boolean
-): ReducedCell {
-	const classShares = new Map<string, number>()
-
-	let unrated = 0
-	let notRateable = 0
-	let noData = 0
-
-	for (const [mukey, weight] of weights) {
-		const profile = profiles.get(mukey)
-
-		if (!profile) {
-			throw new Error(
-				`soil reduce: cell ${h3Cell} names map unit ${mukey}, which the attribute join does not hold — a missing profile means the join is short, and reducing the remaining candidates would report a well-formed distribution over part of the cell`
-			)
-		}
-
-		for (const [code, share] of profile.classShares) {
-			classShares.set(code, (classShares.get(code) ?? 0) + share * weight)
-		}
-
-		unrated += profile.unrated * weight
-		notRateable += profile.notRateable * weight
-		noData += profile.noData * weight
-	}
-
-	// The floor truncates the long tail component percentages create inside a lattice child. The remainder is stored
-	// rather than dropped, so the five shares sum to 1 and a reader can see how much was folded away.
-	let other = 0
-	const kept: Array<[string, number]> = []
-
-	for (const [code, share] of classShares) {
-		if (share < CLASS_SHARE_FLOOR) {
-			other += share
-		} else {
-			kept.push([code, share])
-		}
-	}
-
-	kept.sort((left, right) => right[1] - left[1] || (left[0] < right[0] ? -1 : 1))
-
-	const top = kept[0]
-
-	return {
-		row: {
-			h3_cell: h3Cell,
-			class_shares: JSON.stringify(Object.fromEntries(kept.map(([code, share]) => [code, round(share)]))),
-			unrated_share: round(unrated),
-			notrateable_share: round(notRateable),
-			nodata_share: round(noData),
-			other_share: round(other),
-			mapped_share: round(mappedShare),
-			top_class: top ? top[0] : null,
-			top_class_share: top ? round(top[1]) : null,
-			weighting: SOIL_SHARE_WEIGHTING,
-			delineations,
-		},
-		topClassUnderHalf: !top || top[1] < 0.5,
-		sampled,
-	}
-}
-
-/**
- * A cell no lattice point landed inside. `mapped_share` zero says exactly that, and the caller drops it rather than
- * storing an all-zero distribution that would read as a surveyed cell holding nothing.
- */
-function emptyRow(h3Cell: number, delineations: number): SoilCapabilityCellTable {
-	return {
-		h3_cell: h3Cell,
-		class_shares: "{}",
-		unrated_share: 0,
-		notrateable_share: 0,
-		nodata_share: 0,
-		other_share: 0,
-		mapped_share: 0,
-		top_class: null,
-		top_class_share: null,
-		weighting: SOIL_SHARE_WEIGHTING,
-		delineations,
-	}
-}
-
-/**
- * Six decimals — a millionth of a cell, far below the lattice's own 2% granularity, and enough that the stored shares
- * still sum to 1 within a rounding error a reader can see is rounding.
- */
-const SHARE_DECIMALS = 6
-
-function round(value: number): number {
-	return Number(value.toFixed(SHARE_DECIMALS))
-}
-
-/**
- * The sum of a stored row's five shares. Exported because the invariant it checks — that they sum to 1 — is what makes
- * `other_share` required rather than decorative, and a test that could not state the sum could not pin it.
- */
-export function shareTotal(row: SoilCapabilityCellTable): number {
-	const classes = parseJSONStrict<Record<string, number>>(row.class_shares)
-
-	let total = row.unrated_share + row.notrateable_share + row.nodata_share + row.other_share
-
-	for (const share of Object.values(classes)) {
-		total += share
-	}
-
-	return total
-}

package/out/scripts/ingest-chunk.d.ts

@@ -1,11 +0,0 @@
-/**
- * @copyright Sister Software
- * @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.
- */
-export {};
-//# sourceMappingURL=ingest-chunk.d.ts.map

package/out/scripts/ingest-chunk.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ingest-chunk.d.ts","sourceRoot":"","sources":["../../lib/scripts/ingest-chunk.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/out/scripts/ingest-chunk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ingest-chunk.js","sourceRoot":"","sources":["../../lib/scripts/ingest-chunk.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAA;AACtE,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,+CAA+C,CAAA;AAIxG,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAEnD,MAAM,oBAAoB,CAAC;IAC1B,OAAO,EAAE,mBAAmB;IAC5B,OAAO,EAAE;QACR,GAAG,kBAAkB;QACrB,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAC7B,aAAa,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QACjC,UAAU,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAC9B,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAC5B,mBAAmB,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;KACvC;IACD,GAAG,EAAE,KAAK,EAAE,QAAsC,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CACpE,eAAe,CAAC,QAAQ,EAAE;QACzB,MAAM,EAAE,MAAM,4BAA4B,CAAC;YAC1C,aAAa,EAAE,gBAAgB,CAAC,mBAAmB,EAAE,WAAW,EAAE,MAAM,CAAC,SAAS,CAAC;YACnF,UAAU,EAAE,gBAAgB,CAAC,mBAAmB,EAAE,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,CAAC;YACvF,OAAO,EAAE,MAAM,CAAC,gBAAgB,CAAC,mBAAmB,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;YACtF,KAAK,EAAE,MAAM,CAAC,gBAAgB,CAAC,mBAAmB,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YAChF,+GAA+G;YAC/G,2GAA2G;YAC3G,oBAAoB,EAAE,CAAC;SACvB,CAAC;QACF,eAAe,EAAE,KAAK,CAAC,eAAe;QACtC,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;QAC5C,kHAAkH;QAClH,yGAAyG;QACzG,eAAe,EAAE,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC5G,UAAU,EAAE,KAAK,CAAC,UAAU;KAC5B,CAAC;CACH,CAAC,CAAA"}

package/out/sdk/index.d.ts

@@ -1,20 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- * @file The acquisition + build surface for the NRCS SSURGO soil-capability layer. The READER is the
- *   package root.
- */
-export * from "#sdk/acquire";
-export * from "#sdk/build-soil";
-export * from "#sdk/cell-tiers";
-export * from "#sdk/cells";
-export * from "#sdk/client";
-export * from "#sdk/download";
-export * from "#sdk/ingest";
-export * from "#sdk/measure-resolutions";
-export * from "#sdk/reduce";
-export * from "#sdk/survey-area";
-export * from "#sdk/tabular";
-export * from "#sdk/verify";
-//# sourceMappingURL=index.d.ts.map