bruce-models 7.1.87 → 7.1.89

package/dist/bruce-models.es5.js

@@ -9279,82 +9279,6 @@ var ClientFile;
         });
     }
     ClientFile.GetList = GetList;
-    function GetFindGeneratedTextureCacheKey(entityTypeSourceId, attribute) {
-        return `client-file-find-generated-texture-${entityTypeSourceId}-${attribute}`;
-    }
-    const GENERATED_TEXTURE_PURPOSE = "Polygon Texture, ValueMap";
-    const GENERATED_TEXTURE_SOURCE_PATH = "generation/Identity/EntityTypeSourceID";
-    const GENERATED_TEXTURE_ATTRIBUTE_PATH = "generation/Identity/Attribute";
-    /**
-     * Whether a file is the generated value map for this source and attribute.
-     */
-    function IsGeneratedTextureFor(file, entityTypeSourceId, attribute) {
-        var _a, _b;
-        const identity = (_b = (_a = file === null || file === void 0 ? void 0 : file.Data) === null || _a === void 0 ? void 0 : _a.generation) === null || _b === void 0 ? void 0 : _b.Identity;
-        if (!identity) {
-            return false;
-        }
-        // A source ID reaches us as a number from the API and as a string from a filter echo.
-        return Number(identity.EntityTypeSourceID) === Number(entityTypeSourceId) && identity.Attribute === attribute;
-    }
-    ClientFile.IsGeneratedTextureFor = IsGeneratedTextureFor;
-    /**
-     * Returns a generated texture file for given source ID + attribute combination.
-     */
-    function FindGeneratedTexture(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let { api, entityTypeSourceId, attribute, req: reqParams } = params;
-            if (!api) {
-                api = ENVIRONMENT.Api().GetBruceApi();
-            }
-            const key = GetFindGeneratedTextureCacheKey(entityTypeSourceId, attribute);
-            const cache = api.GetCacheItem(key, reqParams);
-            if (cache === null || cache === void 0 ? void 0 : cache.found) {
-                return cache.data;
-            }
-            // Hack: API isn't returning the right file so we're adding to page size and filtering again on client. Patch ASAP.
-            const prom = (() => __awaiter(this, void 0, void 0, function* () {
-                const res = yield GetList({
-                    api,
-                    filter: {
-                        PageSize: 300,
-                        PageIndex: 0,
-                        Purpose: GENERATED_TEXTURE_PURPOSE,
-                        FilterRows: [
-                            {
-                                column: Filter.EColumn.Data,
-                                path: GENERATED_TEXTURE_SOURCE_PATH,
-                                rowOperator: Filter.ERowOperator.AND,
-                                value: String(entityTypeSourceId),
-                                includes: true,
-                                valueOperator: "equals",
-                                rows: []
-                            },
-                            {
-                                column: Filter.EColumn.Data,
-                                path: GENERATED_TEXTURE_ATTRIBUTE_PATH,
-                                rowOperator: Filter.ERowOperator.AND,
-                                value: attribute,
-                                includes: true,
-                                valueOperator: "equals",
-                                rows: []
-                            }
-                        ]
-                    },
-                    req: reqParams
-                });
-                const match = (res.clientFiles || []).find((file) => IsGeneratedTextureFor(file, entityTypeSourceId, attribute));
-                return match || null;
-            }))();
-            api.SetCacheItem({
-                key,
-                value: prom,
-                req: reqParams
-            });
-            return prom;
-        });
-    }
-    ClientFile.FindGeneratedTexture = FindGeneratedTexture;
     /**
      * Deletes a list of client files matching the filter.
      * @param params
@@ -9446,6 +9370,660 @@ var ClientFile;
     ClientFile.GetCountsUserCacheKey = GetCountsUserCacheKey;
 })(ClientFile || (ClientFile = {}));
 
+/**
+ * Reading what a published value map declares, without decoding a single pixel.
+ */
+var ValueMapMetadata;
+(function (ValueMapMetadata) {
+    // The only shape this library reads. The generations differ enough that a partial reading
+    // produces plausible numbers rather than an error, which is why anything else is refused.
+    ValueMapMetadata.SUPPORTED_VERSION = 3;
+    // Byte references are published only under Tiles, so any other layout carries no readable pixels at all.
+    ValueMapMetadata.LAYOUT_TILES = "tiles";
+    ValueMapMetadata.LAYOUT_SINGLE = "single";
+    // Value in R at 8 bits, or high in R and low in G at 16.
+    ValueMapMetadata.FORMAT_U8 = "u8";
+    ValueMapMetadata.FORMAT_RG16 = "rg16";
+    // A flag in alpha rather than a number, so a mask layer declares no range.
+    ValueMapMetadata.FORMAT_MASK = "mask";
+    // Declared as a field with one value, so a second mode can be added later without an absent
+    // Encoding having to mean anything.
+    ValueMapMetadata.ENCODING_ABSOLUTE = "absolute";
+    // One raster per entry in Series.Times.
+    ValueMapMetadata.LAYER_VALUE = "Value";
+    // Per-texel minimum and maximum over the whole series, as statistics rather than as part of
+    // the encoding.
+    ValueMapMetadata.LAYER_VALUE_MIN = "ValueMin";
+    ValueMapMetadata.LAYER_VALUE_MAX = "ValueMax";
+    // Texels that held their own minimum for the whole series, flagged in alpha.
+    ValueMapMetadata.LAYER_BASELINE = "Baseline";
+    // The per-texel correction applied to the source's numbers, on an archive that was transformed.
+    ValueMapMetadata.LAYER_VALUE_SHIFT = "ValueShift";
+    // A layer's alpha says whether a texel was sampled at all, so a transparent texel means no data
+    // rather than a value of zero.
+    // Alpha is per layer: masking one layer with another's coverage reports readings no texel holds.
+    ValueMapMetadata.NO_DATA = 0;
+    // Heights already on the ellipsoid, which are the only ones placeable without a shift.
+    ValueMapMetadata.DATUM_ELLIPSOIDAL = "WGS84";
+    ValueMapMetadata.DATUMS_ELLIPSOIDAL = ["WGS84", "ellipsoidal"];
+    /**
+     * The published block on a Client File record, or undefined when it carries none.
+     */
+    function Of(file) {
+        const generation = file && file.Data ? file.Data.generation : undefined;
+        return generation ? generation : undefined;
+    }
+    ValueMapMetadata.Of = Of;
+    /**
+     * Whether a record is a value map this library can read.
+     */
+    function IsReadable(metadata) {
+        return Unreadable(metadata) === null;
+    }
+    ValueMapMetadata.IsReadable = IsReadable;
+    /**
+     * Why an archive cannot be read, or null when it can.
+     *
+     * Returned rather than thrown so a renderer can warn and draw nothing while an analysis caller
+     * turns the same sentence into an error. Both then say the same thing.
+     */
+    function Unreadable(metadata) {
+        if (!metadata) {
+            return "This Client File carries no generation block, so it is not a generated value map.";
+        }
+        const at = metadata.Identity ? metadata.Identity.Generated : undefined;
+        const generated = at ? " It was generated " + at + ", so regenerating it is the likely fix." : "";
+        if (metadata.Version !== ValueMapMetadata.SUPPORTED_VERSION) {
+            const found = metadata.Version != null ? String(metadata.Version) : "unstated";
+            return ("This value map is generation " + found + " and this library reads only generation "
+                + ValueMapMetadata.SUPPORTED_VERSION + "." + generated);
+        }
+        const encoding = metadata.Value ? metadata.Value.Encoding : undefined;
+        if (encoding && encoding !== ValueMapMetadata.ENCODING_ABSOLUTE) {
+            return ("This value map is encoded as " + encoding + ", and this library reads only "
+                + ValueMapMetadata.ENCODING_ABSOLUTE + "." + generated);
+        }
+        const layout = metadata.Geometry ? metadata.Geometry.Layout : undefined;
+        if (layout !== ValueMapMetadata.LAYOUT_TILES) {
+            return ("This value map declares a " + (layout || "missing") + " layout, and generation "
+                + ValueMapMetadata.SUPPORTED_VERSION + " publishes byte references only under Tiles, so there are no"
+                + " pixels to read." + generated);
+        }
+        if (!(metadata.Tiles || []).length) {
+            return ("This value map declares a tiled layout but publishes no tiles, so there are no"
+                + " pixels to read." + generated);
+        }
+        return null;
+    }
+    ValueMapMetadata.Unreadable = Unreadable;
+    /**
+     * The tiles coarsest first, which is the order a reader has to composite them in.
+     *
+     * Tiles overlap and the finer one is the better answer, so assigning coarse first leaves the
+     * finest tile holding each texel it covers.
+     */
+    function TilesOf(metadata) {
+        const tiles = (metadata && metadata.Tiles ? metadata.Tiles : []).slice();
+        tiles.sort((left, right) => {
+            const byLevel = (left.Level || 0) - (right.Level || 0);
+            return byLevel !== 0 ? byLevel : (right.TexelMetres || 0) - (left.TexelMetres || 0);
+        });
+        return tiles;
+    }
+    ValueMapMetadata.TilesOf = TilesOf;
+    /**
+     * One layer's declaration, or undefined when the archive does not carry it.
+     */
+    function LayerOf(metadata, name) {
+        const layers = metadata && metadata.Layers ? metadata.Layers : [];
+        for (const layer of layers) {
+            if (layer && layer.Name === name) {
+                return layer;
+            }
+        }
+        return undefined;
+    }
+    ValueMapMetadata.LayerOf = LayerOf;
+    /**
+     * The range one layer was quantised between, or null for a mask and for a layer that is absent.
+     *
+     * A statistics layer is encoded over the true data range rather than over the frames' own, so
+     * reading it with the frame range is a plausible wrong answer.
+     */
+    function LayerRange(metadata, name) {
+        const layer = LayerOf(metadata, name);
+        if (!layer || typeof layer.Min !== "number" || typeof layer.Max !== "number") {
+            return null;
+        }
+        return { Min: layer.Min, Max: layer.Max };
+    }
+    ValueMapMetadata.LayerRange = LayerRange;
+    /**
+     * The values a reading out of this archive falls between, in its delivered units.
+     */
+    function ValueRange(metadata) {
+        const value = (metadata && metadata.Value) || {};
+        return {
+            Min: typeof value.Min === "number" ? value.Min : 0,
+            Max: typeof value.Max === "number" ? value.Max : 1
+        };
+    }
+    ValueMapMetadata.ValueRange = ValueRange;
+    /**
+     * The values the source's own numbers fall between, or null where nothing was transformed.
+     */
+    function SourceRange(metadata) {
+        const source = (metadata && metadata.ValueSource) || {};
+        if (typeof source.Min !== "number" || typeof source.Max !== "number") {
+            return null;
+        }
+        return { Min: source.Min, Max: source.Max };
+    }
+    ValueMapMetadata.SourceRange = SourceRange;
+    /**
+     * What was applied to the source's numbers to get the delivered ones, empty for nothing.
+     */
+    function TransformOf(metadata) {
+        const source = metadata && metadata.ValueSource;
+        return (source && source.Transform) || "";
+    }
+    ValueMapMetadata.TransformOf = TransformOf;
+    /**
+     * Whether a delivered reading differs from what the source's own data said.
+     *
+     * Both halves are needed: the transform names what happened, and the ValueShift layer is the
+     * only thing that can undo it per texel.
+     */
+    function IsTransformed(metadata) {
+        return !!TransformOf(metadata) && !!LayerOf(metadata, ValueMapMetadata.LAYER_VALUE_SHIFT);
+    }
+    ValueMapMetadata.IsTransformed = IsTransformed;
+    /**
+     * What a picture should be ramped over where the source suggests one, which is not a bound on the data.
+     */
+    function ColorBarRange(metadata) {
+        const hints = (metadata && metadata.Hints) || {};
+        if (typeof hints.ColorBarMin !== "number" || typeof hints.ColorBarMax !== "number") {
+            return null;
+        }
+        return { Min: hints.ColorBarMin, Max: hints.ColorBarMax };
+    }
+    ValueMapMetadata.ColorBarRange = ColorBarRange;
+    /**
+     * When each frame was sampled. Authoritative, unlike Series.Increment.
+     */
+    function TimesOf(metadata) {
+        const series = (metadata && metadata.Series) || {};
+        return (series.Times || []).slice();
+    }
+    ValueMapMetadata.TimesOf = TimesOf;
+    /**
+     * Whether the archive holds every timestep that was asked for.
+     *
+     * A short archive is otherwise indistinguishable from a short series, and the failure it hides
+     * is a skipped timestep in the middle of the event rather than a shorter one.
+     */
+    function IsComplete(metadata) {
+        const series = (metadata && metadata.Series) || {};
+        if (series.Complete != null) {
+            return !!series.Complete;
+        }
+        const written = typeof series.Written === "number" ? series.Written : TimesOf(metadata).length;
+        return (series.Requested || 0) === written;
+    }
+    ValueMapMetadata.IsComplete = IsComplete;
+    /**
+     * Says so when an archive's heights are not on the ellipsoid they will be drawn against.
+     *
+     * Returned rather than logged, so the renderer keeps its console warning and an analysis caller
+     * can put the same sentence in a report.
+     */
+    function UnshiftedWarning(metadata) {
+        const source = (metadata && metadata.ValueSource) || {};
+        const datum = source.VerticalDatum;
+        if (!datum || ValueMapMetadata.DATUMS_ELLIPSOIDAL.indexOf(datum) >= 0 || TransformOf(metadata)) {
+            return null;
+        }
+        const at = metadata && metadata.Identity ? metadata.Identity.Generated : undefined;
+        return ("These value map heights are in " + datum + " and report no transform, so they are"
+            + " not ellipsoidal and will be wrong when placed absolutely."
+            +
+                (at ? " The archive was generated at " + at + " and needs regenerating with the shift"
+                    + " applied." : ""));
+    }
+    ValueMapMetadata.UnshiftedWarning = UnshiftedWarning;
+    /**
+     * Where one tile's copy of a layer sits in the blob, or null when it holds none.
+     *
+     * A per-time layer holds one entry per Series.Times element, and a zero length means the tile
+     * held nothing at that time, so the indices stay aligned with the series.
+     */
+    function BytesOf(tile, name, index) {
+        const entry = tile && tile.Layers ? tile.Layers[name] : undefined;
+        if (!entry) {
+            return null;
+        }
+        if (Array.isArray(entry)) {
+            if (index == null || index < 0 || index >= entry.length) {
+                return null;
+            }
+            const at = entry[index];
+            return at && at.Bytes ? at.Bytes : null;
+        }
+        return entry.Bytes || null;
+    }
+    ValueMapMetadata.BytesOf = BytesOf;
+    // How far apart two byte ranges can sit and still be worth reading together.
+    // A wasted byte is far cheaper than a round trip.
+    ValueMapMetadata.MAX_READ_GAP = 131072;
+    /**
+     * The span of the blob a set of byte ranges covers, or null for an empty set.
+     */
+    function SpanOf(ranges) {
+        let low = Number.POSITIVE_INFINITY;
+        let high = Number.NEGATIVE_INFINITY;
+        for (const range of ranges) {
+            if (!range || !range.Length) {
+                continue;
+            }
+            low = Math.min(low, range.Offset);
+            high = Math.max(high, range.Offset + range.Length);
+        }
+        return high > low ? { Offset: low, Length: high - low } : null;
+    }
+    ValueMapMetadata.SpanOf = SpanOf;
+    /**
+     * The rectangle the archive's raster covers, or null when the block does not place it.
+     */
+    function ExtentOf(metadata) {
+        const geometry = (metadata && metadata.Geometry) || {};
+        if (typeof geometry.West !== "number" || typeof geometry.East !== "number" ||
+            typeof geometry.South !== "number" || typeof geometry.North !== "number") {
+            return null;
+        }
+        return {
+            West: geometry.West, East: geometry.East,
+            South: geometry.South, North: geometry.North
+        };
+    }
+    ValueMapMetadata.ExtentOf = ExtentOf;
+    /**
+     * Whether frames carry a 16 bit value packed across R and G.
+     *
+     * Worth asking by name: taking R alone from a packed frame yields a plausible surface quantised
+     * to 255 steps of the full range rather than an obvious failure.
+     */
+    function IsPacked(metadata) {
+        const value = (metadata && metadata.Value) || {};
+        return value.Format === ValueMapMetadata.FORMAT_RG16;
+    }
+    ValueMapMetadata.IsPacked = IsPacked;
+    /**
+     * A value in the attribute's own units as the 0 to 1 position a ramp is indexed by.
+     *
+     * Stops are authored in real units, since "hide anything under 0.1 m" is the sentence a user
+     * actually has, and the archive's published range is what makes that expressible.
+     */
+    function Normalise(value, range) {
+        const span = range.Max - range.Min;
+        if (!(span > 0)) {
+            return 0;
+        }
+        return Math.min(1, Math.max(0, (value - range.Min) / span));
+    }
+    ValueMapMetadata.Normalise = Normalise;
+    /**
+     * A 0 to 1 position back in the attribute's own units.
+     */
+    function Denormalise(position, range) {
+        return range.Min + position * (range.Max - range.Min);
+    }
+    ValueMapMetadata.Denormalise = Denormalise;
+    /**
+     * The packed number at one texel, straight out of the channels, whatever the format.
+     */
+    function PackedAt(pixels, at, format) {
+        return format === ValueMapMetadata.FORMAT_RG16 ? pixels[at] * 256 + pixels[at + 1] : pixels[at];
+    }
+    ValueMapMetadata.PackedAt = PackedAt;
+    /**
+     * The 0 to 1 reading at one texel, for a caller indexing a ramp rather than reporting a number.
+     */
+    function NormalisedAt(pixels, at, format) {
+        return PackedAt(pixels, at, format) / (format === ValueMapMetadata.FORMAT_RG16 ? 65535 : 255);
+    }
+    ValueMapMetadata.NormalisedAt = NormalisedAt;
+    /**
+     * The reads that cover a set of byte ranges, adjacent ones merged and distant ones left apart.
+     *
+     * What stops a caller having to choose between one round trip per entry and one download of
+     * everything between the first entry and the last.
+     */
+    function PlanReads(ranges, maxGap) {
+        const gap = maxGap == null ? ValueMapMetadata.MAX_READ_GAP : maxGap;
+        const wanted = ranges
+            .filter((at) => at && at.Length > 0)
+            .slice()
+            .sort((left, right) => left.Offset - right.Offset);
+        const reads = [];
+        for (const at of wanted) {
+            const last = reads[reads.length - 1];
+            const end = last ? last.Offset + last.Length : 0;
+            if (last && at.Offset - end <= gap) {
+                last.Length = Math.max(end, at.Offset + at.Length) - last.Offset;
+                continue;
+            }
+            reads.push({ Offset: at.Offset, Length: at.Length });
+        }
+        return reads;
+    }
+    ValueMapMetadata.PlanReads = PlanReads;
+    /**
+     * A packed channel reading as the number it stands for.
+     * value = Min + packed / fullScale * (Max - Min), where packed is R at 8 bits and R * 256 + G at 16.
+     */
+    function Decode(packed, format, range) {
+        const fullScale = format === ValueMapMetadata.FORMAT_RG16 ? 65535 : 255;
+        return range.Min + (packed / fullScale) * (range.Max - range.Min);
+    }
+    ValueMapMetadata.Decode = Decode;
+})(ValueMapMetadata || (ValueMapMetadata = {}));
+
+/**
+ * The mapping between a value map's raster and the world.
+ * Turns a position, a bounding box or a ring into the texels they cover, and a texel back into a position.
+ */
+var ValueMapGrid;
+(function (ValueMapGrid) {
+    /**
+     * A grid over one archive's extent.
+     */
+    class Grid {
+        /**
+         * A grid over a Geometry block, sized either by the block or by a composite passed in.
+         */
+        constructor(geometry, width, height, extent) {
+            const block = Object.assign({}, geometry || {}, extent || {});
+            const needed = ["West", "East", "South", "North"];
+            if (width == null || height == null) {
+                needed.push("ResolutionX", "ResolutionY");
+            }
+            for (const key of needed) {
+                if (block[key] == null) {
+                    throw new Error("The value map's Geometry block has no " + key
+                        + ", so its raster cannot be placed on the world.");
+                }
+            }
+            this.Width = width != null ? Math.round(width) : Math.round(block.ResolutionX);
+            this.Height = height != null ? Math.round(height) : Math.round(block.ResolutionY);
+            this.West = block.West;
+            this.East = block.East;
+            this.South = block.South;
+            this.North = block.North;
+            this.LonStep = (this.East - this.West) / this.Width;
+            this.LatStep = (this.North - this.South) / this.Height;
+        }
+        /**
+         * The position of a texel corner.
+         */
+        Corner(x, y) {
+            return {
+                Longitude: this.West + x * this.LonStep,
+                Latitude: this.North - y * this.LatStep
+            };
+        }
+        /**
+         * The position at the middle of a texel, which is where its value was sampled.
+         */
+        Centre(row, column) {
+            return {
+                Longitude: this.West + (column + 0.5) * this.LonStep,
+                Latitude: this.North - (row + 0.5) * this.LatStep
+            };
+        }
+        /**
+         * The texel covering a position, or null when it falls outside the raster.
+         */
+        TexelAt(longitude, latitude) {
+            const column = Math.floor((longitude - this.West) / this.LonStep);
+            const row = Math.floor((this.North - latitude) / this.LatStep);
+            if (row >= 0 && row < this.Height && column >= 0 && column < this.Width) {
+                return { Row: row, Column: column };
+            }
+            return null;
+        }
+        /**
+         * A ring of texel corners as positions.
+         */
+        RingToPoints(ring) {
+            return ring.map((corner) => this.Corner(corner.X, corner.Y));
+        }
+        /**
+         * Every texel a bounding box covers, clipped to the raster.
+         *
+         * The whole box rather than its middle, since something smaller than a texel still lands on
+         * two when it sits on the join, and reading only the centre would miss the other one.
+         */
+        TexelsIn(bounds) {
+            if (!bounds) {
+                return [];
+            }
+            const west = bounds.minLongitude;
+            const east = bounds.maxLongitude;
+            const south = bounds.minLatitude;
+            const north = bounds.maxLatitude;
+            if (west == null || east == null || south == null || north == null) {
+                return [];
+            }
+            if (east < this.West || west > this.East || north < this.South || south > this.North) {
+                return [];
+            }
+            // Clamped rather than dropped, so a box overlapping an edge keeps the part that is on
+            // the raster instead of reporting nothing.
+            const left = this.clampColumn((west - this.West) / this.LonStep);
+            const right = this.clampColumn((east - this.West) / this.LonStep);
+            const top = this.clampRow((this.North - north) / this.LatStep);
+            const bottom = this.clampRow((this.North - south) / this.LatStep);
+            const hits = [];
+            for (let row = top; row <= bottom; row++) {
+                for (let column = left; column <= right; column++) {
+                    hits.push({ Row: row, Column: column });
+                }
+            }
+            return hits;
+        }
+        /**
+         * Every texel a closed ring actually touches, rather than every texel its box covers.
+         *
+         * A box always claims at least as much as the shape inside it, so this can only ever take texels away.
+         *
+         * Slivers count: a ring clipping the corner of a texel has water there as much
+         * as one sitting in the middle of it, so an edge crossing the cell is a hit on its own.
+         */
+        TexelsUnder(ring) {
+            const points = (ring || []).map((point) => ({
+                Longitude: point.Longitude,
+                Latitude: point.Latitude
+            }));
+            if (points.length < 3) {
+                return [];
+            }
+            const first = points[0];
+            const last = points[points.length - 1];
+            if (first.Longitude !== last.Longitude || first.Latitude !== last.Latitude) {
+                points.push(first);
+            }
+            let minLon = Number.POSITIVE_INFINITY;
+            let maxLon = Number.NEGATIVE_INFINITY;
+            let minLat = Number.POSITIVE_INFINITY;
+            let maxLat = Number.NEGATIVE_INFINITY;
+            for (const point of points) {
+                minLon = Math.min(minLon, point.Longitude);
+                maxLon = Math.max(maxLon, point.Longitude);
+                minLat = Math.min(minLat, point.Latitude);
+                maxLat = Math.max(maxLat, point.Latitude);
+            }
+            if (maxLon < this.West || minLon > this.East || maxLat < this.South || minLat > this.North) {
+                return [];
+            }
+            const left = this.clampColumn((minLon - this.West) / this.LonStep);
+            const right = this.clampColumn((maxLon - this.West) / this.LonStep);
+            const top = this.clampRow((this.North - maxLat) / this.LatStep);
+            const bottom = this.clampRow((this.North - minLat) / this.LatStep);
+            const hits = [];
+            for (let row = top; row <= bottom; row++) {
+                const north = this.North - row * this.LatStep;
+                const south = north - this.LatStep;
+                for (let column = left; column <= right; column++) {
+                    const west = this.West + column * this.LonStep;
+                    const east = west + this.LonStep;
+                    if (CellMeetsRing(points, west, east, south, north)) {
+                        hits.push({ Row: row, Column: column });
+                    }
+                }
+            }
+            return hits;
+        }
+        clampColumn(at) {
+            return Math.max(0, Math.min(this.Width - 1, Math.floor(at)));
+        }
+        clampRow(at) {
+            return Math.max(0, Math.min(this.Height - 1, Math.floor(at)));
+        }
+    }
+    ValueMapGrid.Grid = Grid;
+    // Metres per degree at the equator, used only to work out how many texels an extent implies at a given ground resolution.
+    const METRES_PER_DEGREE_LON = 111320;
+    const METRES_PER_DEGREE_LAT = 110574;
+    /**
+     * The grid a set of tiles should be composited onto, sized so the finest one keeps its detail.
+     *
+     * Capped, because a pyramid's finest tile can imply a raster far larger than either an analysis
+     * or a texture upload needs, and every frame pays for it.
+     */
+    function CompositeSize(tiles, extent, cap) {
+        let finest = 0;
+        for (const tile of tiles || []) {
+            if (tile.TexelMetres > 0 && (!finest || tile.TexelMetres < finest)) {
+                finest = tile.TexelMetres;
+            }
+        }
+        if (!(finest > 0)) {
+            finest = 1;
+        }
+        const middle = ((extent.South + extent.North) / 2) * Math.PI / 180;
+        const widthMetres = Math.max((extent.East - extent.West) * METRES_PER_DEGREE_LON * Math.cos(middle), 1);
+        const heightMetres = Math.max((extent.North - extent.South) * METRES_PER_DEGREE_LAT, 1);
+        let width = Math.max(1, Math.ceil(widthMetres / finest));
+        let height = Math.max(1, Math.ceil(heightMetres / finest));
+        const longest = Math.max(width, height);
+        if (cap > 0 && longest > cap) {
+            const shrink = cap / longest;
+            width = Math.max(1, Math.round(width * shrink));
+            height = Math.max(1, Math.round(height * shrink));
+        }
+        return { Width: width, Height: height };
+    }
+    ValueMapGrid.CompositeSize = CompositeSize;
+    /**
+     * Where one tile lands on a composite of that size over that extent.
+     */
+    function TileRect(tile, extent, size) {
+        const spanLon = extent.East - extent.West;
+        const spanLat = extent.North - extent.South;
+        const left = Math.round((tile.West - extent.West) / spanLon * size.Width);
+        const right = Math.round((tile.East - extent.West) / spanLon * size.Width);
+        const top = Math.round((extent.North - tile.North) / spanLat * size.Height);
+        const bottom = Math.round((extent.North - tile.South) / spanLat * size.Height);
+        return {
+            Left: left,
+            Top: top,
+            Width: Math.max(1, right - left),
+            Height: Math.max(1, bottom - top)
+        };
+    }
+    ValueMapGrid.TileRect = TileRect;
+    /**
+     * Whether a position falls inside a closed ring, by the crossing count.
+     */
+    function PointInRing(points, longitude, latitude) {
+        let inside = false;
+        for (let at = 0; at < points.length - 1; at++) {
+            const from = points[at];
+            const to = points[at + 1];
+            if ((from.Latitude > latitude) !== (to.Latitude > latitude)) {
+                const crossing = from.Longitude
+                    + (latitude - from.Latitude) / (to.Latitude - from.Latitude)
+                        * (to.Longitude - from.Longitude);
+                if (crossing > longitude) {
+                    inside = !inside;
+                }
+            }
+        }
+        return inside;
+    }
+    ValueMapGrid.PointInRing = PointInRing;
+    /**
+     * Whether a texel's rectangle and a closed ring overlap at all.
+     */
+    function CellMeetsRing(points, west, east, south, north) {
+        if (PointInRing(points, (west + east) / 2, (south + north) / 2)) {
+            return true;
+        }
+        for (const point of points) {
+            if (point.Longitude >= west && point.Longitude <= east
+                && point.Latitude >= south && point.Latitude <= north) {
+                return true;
+            }
+        }
+        const corners = [
+            { Longitude: west, Latitude: south },
+            { Longitude: east, Latitude: south },
+            { Longitude: east, Latitude: north },
+            { Longitude: west, Latitude: north },
+            { Longitude: west, Latitude: south }
+        ];
+        for (let at = 0; at < points.length - 1; at++) {
+            for (let side = 0; side < 4; side++) {
+                if (SegmentsCross(points[at], points[at + 1], corners[side], corners[side + 1])) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    ValueMapGrid.CellMeetsRing = CellMeetsRing;
+    /**
+     * Whether two segments intersect, including when one merely touches the other.
+     */
+    function SegmentsCross(a, b, c, d) {
+        const side = (p, q, r) => (q.Longitude - p.Longitude) * (r.Latitude - p.Latitude) - (q.Latitude - p.Latitude) * (r.Longitude - p.Longitude);
+        const d1 = side(c, d, a);
+        const d2 = side(c, d, b);
+        const d3 = side(a, b, c);
+        const d4 = side(a, b, d);
+        if (((d1 > 0) !== (d2 > 0)) && ((d3 > 0) !== (d4 > 0))) {
+            return true;
+        }
+        // Touching counts, so a ring running exactly along a texel edge is not missed.
+        return ((d1 === 0 && OnSegment(c, d, a)) ||
+            (d2 === 0 && OnSegment(c, d, b)) ||
+            (d3 === 0 && OnSegment(a, b, c)) ||
+            (d4 === 0 && OnSegment(a, b, d)));
+    }
+    ValueMapGrid.SegmentsCross = SegmentsCross;
+    /**
+     * Whether a point already known to be on a segment's line lies between its ends.
+     */
+    function OnSegment(from, to, at) {
+        return (at.Longitude >= Math.min(from.Longitude, to.Longitude) &&
+            at.Longitude <= Math.max(from.Longitude, to.Longitude) &&
+            at.Latitude >= Math.min(from.Latitude, to.Latitude) &&
+            at.Latitude <= Math.max(from.Latitude, to.Latitude));
+    }
+    ValueMapGrid.OnSegment = OnSegment;
+})(ValueMapGrid || (ValueMapGrid = {}));
+
 /**
  * GeoJSON data structures.
  */
@@ -9893,128 +10471,1838 @@ var Geometry;
                 if (geo.Point) {
                     merged.Point = geo.Point;
                 }
-                else if (geo.LineString) {
-                    merged.LineString = geo.LineString;
+                else if (geo.LineString) {
+                    merged.LineString = geo.LineString;
+                }
+                else if (geo.Polygon) {
+                    merged.Polygon = geo.Polygon;
+                }
+            };
+            full.MultiGeometry.forEach(addToMerged);
+            return {
+                geometry: merged,
+                properties: properties
+            };
+        }
+        // If there are many polygons but only 1 line and/or 1 point then we'll put those singles into the top-level.
+        // Eg: 5 polygons, 1 point, 1 line. That should be a single geometry.
+        if (countsPerType.Polygon > 1 && (countsPerType.LineString <= 1 && countsPerType.Point <= 1)) {
+            const semiMerged = {};
+            const addToSemiMerged = (geo) => {
+                if (geo.Point) {
+                    semiMerged.Point = geo.Point;
+                }
+                else if (geo.LineString) {
+                    semiMerged.LineString = geo.LineString;
+                }
+            };
+            semiMerged.MultiGeometry = full.MultiGeometry.filter(geo => geo.Polygon);
+            full.MultiGeometry.forEach(addToSemiMerged);
+            return {
+                geometry: semiMerged,
+                properties: properties
+            };
+        }
+        // More than 1 of each, then return the full multi-geometry as-is.
+        return {
+            geometry: full,
+            properties: properties
+        };
+    }
+    Geometry.FromGeoJson = FromGeoJson;
+})(Geometry || (Geometry = {}));
+
+var Bounds;
+(function (Bounds) {
+    /**
+     * Calculates boundaries from entity.
+     * This will not use the entity's boundaries and instead calculate from geometry and location.
+     * @param entity
+     */
+    function FromEntity(entity) {
+        const bounds = {
+            maxAltitude: null,
+            maxLatitude: null,
+            maxLongitude: null,
+            minAltitude: null,
+            minLatitude: null,
+            minLongitude: null
+        };
+        const points = [];
+        const assemblyLocation = Entity.GetValue({
+            entity: entity,
+            path: ["Bruce", "AssemblyLocation"]
+        });
+        if (assemblyLocation) {
+            points.push(assemblyLocation);
+        }
+        const location = Entity.GetValue({
+            entity: entity,
+            path: ["Bruce", "Location"]
+        });
+        if (location) {
+            points.push(location);
+        }
+        const geometry = Entity.GetValue({
+            entity: entity,
+            path: ["Bruce", "VectorGeometry"]
+        });
+        const processGeometry = (geometry, depth = 0) => {
+            if (!geometry || depth > 5) {
+                return;
+            }
+            if (geometry.Point) {
+                points.push(...Geometry.ParsePoints(geometry.Point));
+            }
+            if (geometry.LineString) {
+                points.push(...Geometry.ParsePoints(geometry.LineString));
+            }
+            if (geometry.Polygon) {
+                for (const ring of geometry.Polygon) {
+                    points.push(...Geometry.ParsePoints(ring.LinearRing));
+                }
+            }
+            if (geometry.MultiGeometry) {
+                for (const multiGeometry of geometry.MultiGeometry) {
+                    processGeometry(multiGeometry, depth + 1);
+                }
+            }
+        };
+        processGeometry(geometry);
+        for (const point of points) {
+            if (bounds.maxLatitude == null || point.latitude > bounds.maxLatitude) {
+                bounds.maxLatitude = point.latitude;
+            }
+            if (bounds.maxLongitude == null || point.longitude > bounds.maxLongitude) {
+                bounds.maxLongitude = point.longitude;
+            }
+            if (bounds.maxAltitude == null || point.altitude > bounds.maxAltitude) {
+                bounds.maxAltitude = point.altitude;
+            }
+            if (bounds.minLatitude == null || point.latitude < bounds.minLatitude) {
+                bounds.minLatitude = point.latitude;
+            }
+            if (bounds.minLongitude == null || point.longitude < bounds.minLongitude) {
+                bounds.minLongitude = point.longitude;
+            }
+            if (bounds.minAltitude == null || point.altitude < bounds.minAltitude) {
+                bounds.minAltitude = point.altitude;
+            }
+        }
+        return bounds;
+    }
+    Bounds.FromEntity = FromEntity;
+})(Bounds || (Bounds = {}));
+
+/**
+ * Reads a generated value map: its frames, the values in them, and the shapes those values make.
+ */
+var ValueMapReader;
+(function (ValueMapReader) {
+    /*
+        Texels an area needs before it counts as one.
+        A texel is a mesh sample rather than a measurement of ground, so a handful of them
+        touching is usually the edge of the model flickering over the threshold.
+        Pass 1 to keep every one of them.
+    */
+    ValueMapReader.MIN_TEXELS = 8;
+    // How far a reduced outline may move from the traced one, in texels.
+    ValueMapReader.SIMPLIFY_TOLERANCE = 0.25;
+    // Fraction of the busiest frame that counts as the event being under way, used when picking
+    // which frames are worth looking at.
+    ValueMapReader.ONSET_FRACTION = 0.5;
+    // Candidate levels walked when a threshold has to be read off the series.
+    ValueMapReader.LEVELS = 256;
+    // Longest edge of the grid tiles are composited onto. A pyramid's finest tile can imply a
+    // raster far larger than the analysis needs, and every frame pays for it.
+    ValueMapReader.MAX_COMPOSITE_TEXELS = 2048;
+    // Decoded frames kept, since compositing a tiled frame costs one image decode per tile and the
+    // passes over a series each walk the whole thing again.
+    ValueMapReader.FRAME_CACHE = 16;
+    // Single tile rasters kept, which is what a point sample reads instead of a whole composite.
+    ValueMapReader.TILE_CACHE = 32;
+    // How far apart two slices can sit and still be read together, from the format.
+    ValueMapReader.MAX_READ_GAP = ValueMapMetadata.MAX_READ_GAP;
+    class Reader {
+        constructor(params) {
+            this.frames = new Map();
+            this.tileLayers = new Map();
+            this.statistics = new Map();
+            this.thresholds = new Map();
+            this.baseline = undefined;
+            this.unchanging = undefined;
+            this.File = params.file;
+            this.Metadata = ValueMapMetadata.Of(params.file);
+            const refused = ValueMapMetadata.Unreadable(this.Metadata);
+            if (refused) {
+                // An unknown shape decodes into plausible numbers rather than failing, which is why
+                // it is refused here instead of half read.
+                throw new Error(refused);
+            }
+            this.Tiles = ValueMapMetadata.TilesOf(this.Metadata);
+            this.bytes = params.bytes;
+            this.decoder = params.decoder || ValueMapReader.DefaultDecoder;
+            this.Extent = params.extent || ValueMapMetadata.ExtentOf(this.Metadata);
+            if (!this.Extent) {
+                throw new Error("The value map's Geometry block does not place its raster on the"
+                    + " world, so there is nowhere to read it onto.");
+            }
+            const size = ValueMapGrid.CompositeSize(this.Tiles, this.Extent, params.maxCompositeTexels || ValueMapReader.MAX_COMPOSITE_TEXELS);
+            this.Grid = new ValueMapGrid.Grid(this.Metadata.Geometry, size.Width, size.Height, this.Extent);
+        }
+        /**
+         * The attribute this value map was generated from.
+         */
+        get Attribute() {
+            return this.identity().Attribute || null;
+        }
+        /**
+         * What the attribute is called for a reader, where the source names it.
+         */
+        get Label() {
+            return this.identity().Label || null;
+        }
+        /**
+         * The dataset the values came from, since one account holds several over the same mesh.
+         */
+        get Dataset() {
+            return this.identity().Dataset || null;
+        }
+        /**
+         * The Entity Type Source this was generated from.
+         */
+        get EntityTypeSourceID() {
+            const at = this.identity().EntityTypeSourceID;
+            return at == null ? null : Number(at);
+        }
+        /**
+         * When the archive was written, which is what tells two generations of it apart.
+         */
+        get Generated() {
+            return this.identity().Generated || null;
+        }
+        get Revision() {
+            const at = this.identity().Revision;
+            return at == null ? null : Number(at);
+        }
+        /**
+         * The units a reading is in, where the source states them.
+         */
+        get Units() {
+            return (this.Metadata.Value || {}).Units || null;
+        }
+        /**
+         * How a frame's number is packed: one channel or two.
+         */
+        get Format() {
+            return (this.Metadata.Value || {}).Format || ValueMapMetadata.FORMAT_U8;
+        }
+        /**
+         * The values a reading out of this value map falls between, in its own units.
+         */
+        get ValueRange() {
+            return ValueMapMetadata.ValueRange(this.Metadata);
+        }
+        /**
+         * The values the source's own numbers fall between, or null where nothing was transformed.
+         */
+        get SourceRange() {
+            return ValueMapMetadata.SourceRange(this.Metadata);
+        }
+        /**
+         * What the source's own heights are measured from, when the archive says.
+         * A thickness declares none, and an untransformed elevation declares one with no transform.
+         */
+        get VerticalDatum() {
+            return (this.Metadata.ValueSource || {}).VerticalDatum || null;
+        }
+        /**
+         * What was applied to the source's numbers to get the delivered ones, empty for nothing.
+         */
+        get Transform() {
+            return ValueMapMetadata.TransformOf(this.Metadata);
+        }
+        /**
+         * Whether a reading differs from what the source's own data said.
+         */
+        get IsTransformed() {
+            return ValueMapMetadata.IsTransformed(this.Metadata);
+        }
+        /**
+         * What the source suggests a picture be ramped over, which is not a bound on the data.
+         */
+        get ColorBarRange() {
+            return ValueMapMetadata.ColorBarRange(this.Metadata);
+        }
+        /**
+         * The largest movement any one texel made over the series.
+         */
+        get MovingRangeMax() {
+            const stats = this.Metadata.Stats || {};
+            return typeof stats.MovingRangeMax === "number" ? stats.MovingRangeMax : null;
+        }
+        /**
+         * How many timesteps the generator set out to write.
+         */
+        get RequestedFrames() {
+            return (this.Metadata.Series || {}).Requested || 0;
+        }
+        /**
+         * How many it actually wrote.
+         */
+        get WrittenFrames() {
+            const series = this.Metadata.Series || {};
+            return typeof series.Written === "number" ? series.Written : this.Times.length;
+        }
+        /**
+         * Whether the archive holds every timestep that was asked for.
+         */
+        get IsComplete() {
+            return ValueMapMetadata.IsComplete(this.Metadata);
+        }
+        /**
+         * When each frame was sampled. Authoritative, unlike the series increment.
+         */
+        get Times() {
+            return ValueMapMetadata.TimesOf(this.Metadata);
+        }
+        /**
+         * How many frames the archive holds.
+         */
+        get Length() {
+            return this.Times.length;
+        }
+        /**
+         * Says so when the archive's heights are not on the ellipsoid, or null when they are.
+         */
+        Warning() {
+            return ValueMapMetadata.UnshiftedWarning(this.Metadata);
+        }
+        /**
+         * One layer's declaration, or undefined when the archive does not carry it.
+         */
+        Layer(name) {
+            return ValueMapMetadata.LayerOf(this.Metadata, name);
+        }
+        /**
+         * One frame's values and a mask of which texels were sampled.
+         */
+        Frame(index = 0, source = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const position = this.position(index);
+                const key = position + ":" + source;
+                const held = this.frames.get(key);
+                if (held) {
+                    this.frames.delete(key);
+                    this.frames.set(key, held);
+                    return held;
+                }
+                let field = yield this.composite(ValueMapMetadata.LAYER_VALUE, position);
+                if (!field) {
+                    throw new Error("Frame " + index + " has no image in any of this value map's "
+                        + this.Tiles.length + " tiles.");
+                }
+                if (source) {
+                    field = yield this.toSource(field);
+                }
+                this.frames.set(key, field);
+                Trim(this.frames, ValueMapReader.FRAME_CACHE);
+                return field;
+            });
+        }
+        /**
+         * Each texel's lowest value over the series and where that is known, or null.
+         */
+        ValueMin() {
+            return this.statistic(ValueMapMetadata.LAYER_VALUE_MIN);
+        }
+        /**
+         * Each texel's highest value over the series and where that is known, or null.
+         */
+        ValueMax() {
+            return this.statistic(ValueMapMetadata.LAYER_VALUE_MAX);
+        }
+        /**
+         * The per-texel correction applied to the source's own numbers, or null where none was.
+         *
+         * sourceValue = value - shift, which is what makes the transform reversible per texel rather
+         * than only describable in prose.
+         */
+        ValueShift() {
+            return this.statistic(ValueMapMetadata.LAYER_VALUE_SHIFT);
+        }
+        /**
+         * The texels flagged as permanently at their own minimum, or null when none were published.
+         *
+         * A caller measuring change subtracts these rather than reporting ground that never moved.
+         */
+        Baseline() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.baseline !== undefined) {
+                    return this.baseline;
+                }
+                this.baseline = null;
+                if (this.Layer(ValueMapMetadata.LAYER_BASELINE)) {
+                    const field = yield this.composite(ValueMapMetadata.LAYER_BASELINE);
+                    if (field) {
+                        this.baseline = { Width: field.Width, Height: field.Height, Bits: field.Covered };
+                    }
+                }
+                return this.baseline;
+            });
+        }
+        /**
+         * The texels holding one value for the whole series, or null for a single frame archive.
+         */
+        Unchanging() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.unchanging !== undefined) {
+                    return this.unchanging;
+                }
+                this.unchanging = null;
+                if (this.Length < 2) {
+                    return this.unchanging;
+                }
+                let lowest = null;
+                let highest = null;
+                let always = null;
+                let width = 0;
+                let height = 0;
+                for (let index = 0; index < this.Length; index++) {
+                    const frame = yield this.Frame(index);
+                    width = frame.Width;
+                    height = frame.Height;
+                    if (!lowest) {
+                        lowest = frame.Values.slice();
+                        highest = frame.Values.slice();
+                        always = frame.Covered.slice();
+                        continue;
+                    }
+                    for (let at = 0; at < lowest.length; at++) {
+                        lowest[at] = Math.min(lowest[at], frame.Values[at]);
+                        highest[at] = Math.max(highest[at], frame.Values[at]);
+                        // A texel sampled in only some frames is changing, whatever its values did.
+                        always[at] = always[at] && frame.Covered[at] ? 1 : 0;
+                    }
+                }
+                const bits = new Uint8Array(always.length);
+                for (let at = 0; at < bits.length; at++) {
+                    bits[at] = always[at] && lowest[at] === highest[at] ? 1 : 0;
+                }
+                this.unchanging = { Width: width, Height: height, Bits: bits };
+                return this.unchanging;
+            });
+        }
+        /**
+         * Every texel a change in the series cannot be read from, or null when there are none.
+         *
+         * The published baseline and the texels measured as unchanging, since neither describes
+         * anything the series does and a caller asking what moved wants both gone.
+         */
+        Ignored() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const baseline = yield this.Baseline();
+                const unchanging = yield this.Unchanging();
+                if (!baseline) {
+                    return unchanging;
+                }
+                if (!unchanging) {
+                    return baseline;
+                }
+                return Combine(baseline, unchanging, (left, right) => left || right);
+            });
+        }
+        /**
+         * The level the series itself separates on, for a caller who cannot name one.
+         */
+        NaturalThreshold(source = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.thresholds.has(source)) {
+                    return this.thresholds.get(source);
+                }
+                const range = (source && this.SourceRange) || this.ValueRange;
+                this.thresholds.set(source, range.Min);
+                if (this.Length < 2) {
+                    return range.Min;
+                }
+                const step = (range.Max - range.Min) / (ValueMapReader.LEVELS - 1);
+                if (step <= 0) {
+                    return range.Min;
+                }
+                const ignored = yield this.Ignored();
+                const above = [];
+                for (let index = 0; index < this.Length; index++) {
+                    const frame = yield this.Frame(index, source);
+                    const counts = new Float64Array(ValueMapReader.LEVELS);
+                    for (let at = 0; at < frame.Values.length; at++) {
+                        if (!frame.Covered[at] || (ignored && ignored.Bits[at])) {
+                            continue;
+                        }
+                        const level = Math.max(0, Math.min(ValueMapReader.LEVELS - 1, Math.round((frame.Values[at] - range.Min) / step)));
+                        counts[level]++;
+                    }
+                    // Texels strictly above each level, which is what a mask at that level would hold.
+                    const holding = new Array(ValueMapReader.LEVELS);
+                    let running = 0;
+                    for (let level = ValueMapReader.LEVELS - 1; level >= 0; level--) {
+                        holding[level] = running;
+                        running += counts[level];
+                    }
+                    above.push(holding);
+                }
+                let best = 0;
+                let widest = 0;
+                for (let level = 0; level < ValueMapReader.LEVELS; level++) {
+                    const spread = Deviation(above.map((counts) => counts[level]));
+                    if (spread > widest) {
+                        widest = spread;
+                        best = level;
+                    }
+                }
+                if (widest <= 0) {
+                    return range.Min;
+                }
+                this.thresholds.set(source, range.Min + best * step);
+                return this.thresholds.get(source);
+            });
+        }
+        /**
+         * The level to measure against, read off the series when the caller names none.
+         */
+        Resolve(threshold, source = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return threshold == null ? this.NaturalThreshold(source) : threshold;
+            });
+        }
+        /**
+         * The texels in one frame whose value is over a threshold.
+         *
+         * Ask for source to compare against the customer's own numbers, so a level stated against
+         * their data means what they think it means.
+         */
+        MaskAbove(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const source = !!options.source;
+                const frame = yield this.Frame(options.frame || 0, source);
+                const level = yield this.Resolve(options.threshold, source);
+                const bits = new Uint8Array(frame.Values.length);
+                for (let at = 0; at < bits.length; at++) {
+                    bits[at] = frame.Covered[at] && frame.Values[at] > level ? 1 : 0;
+                }
+                const mask = { Width: frame.Width, Height: frame.Height, Bits: bits };
+                if (options.excludeBaseline === false) {
+                    return mask;
+                }
+                const ignored = yield this.Ignored();
+                return ignored ? Combine(mask, ignored, (left, right) => left && !right) : mask;
+            });
+        }
+        /**
+         * The texels over a threshold in every frame, or null for an archive with no frames.
+         *
+         * Measured rather than read off the first frame, so a tide that is out at the start does
+         * not get counted as ground the event flooded.
+         */
+        AlwaysAbove(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                let always = null;
+                for (let index = 0; index < this.Length; index++) {
+                    const mask = yield this.MaskAbove({
+                        threshold: options.threshold,
+                        frame: index,
+                        excludeBaseline: options.excludeBaseline,
+                        source: options.source
+                    });
+                    always = always ? Combine(always, mask, (left, right) => left && right) : mask;
+                }
+                return always;
+            });
+        }
+        /**
+         * One frame's mask with anything below the noise floor already removed.
+         *
+         * Built from the components so the floor is applied once, which is what lets two frames be
+         * compared as sets that already agree on what counts.
+         */
+        CoveredMask(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const mask = yield this.MaskAbove(options);
+                const floor = options.minTexels == null ? ValueMapReader.MIN_TEXELS : options.minTexels;
+                if (floor <= 1) {
+                    return mask;
+                }
+                const keep = new Uint8Array(mask.Bits.length);
+                for (const members of Components(mask, floor)) {
+                    for (const texel of members) {
+                        keep[texel.Row * mask.Width + texel.Column] = 1;
+                    }
+                }
+                return { Width: mask.Width, Height: mask.Height, Bits: keep };
+            });
+        }
+        /**
+         * How many texels are over the threshold in each frame.
+         *
+         * Decoding is local, so the whole series is read without a request and the frames worth
+         * querying can be found rather than guessed at.
+         */
+        Profile(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const floor = options.minTexels == null ? 1 : options.minTexels;
+                const counts = [];
+                for (let index = 0; index < this.Length; index++) {
+                    const mask = floor <= 1
+                        ? yield this.MaskAbove({
+                            threshold: options.threshold,
+                            frame: index,
+                            excludeBaseline: options.excludeBaseline,
+                            source: options.source
+                        })
+                        : yield this.CoveredMask({
+                            threshold: options.threshold,
+                            frame: index,
+                            minTexels: floor,
+                            excludeBaseline: options.excludeBaseline,
+                            source: options.source
+                        });
+                    counts.push(Count(mask));
+                }
+                return counts;
+            });
+        }
+        /**
+         * The frames that characterise an event: it arriving, its worst, and it passing.
+         *
+         * Read off the series rather than named by the caller, since a frame number that suits one
+         * archive is quietly wrong for the next and finding the worst is usually the question.
+         */
+        FramesOfInterest(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const counts = yield this.Profile(options);
+                if (!counts.length) {
+                    return [];
+                }
+                let peak = 0;
+                for (let index = 1; index < counts.length; index++) {
+                    if (counts[index] > counts[peak]) {
+                        peak = index;
+                    }
+                }
+                if (!counts[peak]) {
+                    return [];
+                }
+                const limit = counts[peak] * (options.fraction == null ? ValueMapReader.ONSET_FRACTION : options.fraction);
+                const over = [];
+                counts.forEach((count, index) => {
+                    if (count >= limit) {
+                        over.push(index);
+                    }
+                });
+                // De-duplicated, since a short event can put all three on one frame.
+                const picked = [over[0], peak, over[over.length - 1]];
+                return picked.filter((at, index) => picked.indexOf(at) === index).sort((a, b) => a - b);
+            });
+        }
+        /**
+         * Each area of one frame over a threshold, as a Bruce geometry ready to query with.
+         * Holes are dropped unless asked for.
+         */
+        ShapesAbove(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const mask = yield this.MaskAbove({
+                    threshold: options.threshold,
+                    frame: options.frame,
+                    excludeBaseline: options.excludeBaseline,
+                    source: options.source
+                });
+                return this.ShapesOf(mask, {
+                    minTexels: options.minTexels,
+                    keepHoles: options.keepHoles,
+                    tolerance: options.tolerance
+                });
+            });
+        }
+        /**
+         * Each area of any mask as a Bruce geometry, for a caller who built the mask itself.
+         */
+        ShapesOf(mask, params) {
+            const options = params || {};
+            const floor = options.minTexels == null ? ValueMapReader.MIN_TEXELS : options.minTexels;
+            const shapes = [];
+            for (const members of Components(mask, floor)) {
+                const rings = this.RingsOf(members, options.tolerance);
+                if (rings.Outer.length < ValueMapReader.MIN_RING_POINTS) {
+                    continue;
+                }
+                shapes.push(Polygon(rings.Outer, options.keepHoles ? rings.Holes : []));
+            }
+            return shapes;
+        }
+        /**
+         * One area's outer ring and its holes, as positions.
+         *
+         * The longest ring is the outer one, since a hole is enclosed by what surrounds it. Pass a
+         * tolerance of 0 to keep every traced vertex.
+         */
+        RingsOf(members, tolerance) {
+            const traced = Trace(members);
+            if (!traced.length) {
+                return { Outer: [], Holes: [] };
+            }
+            traced.sort((left, right) => right.length - left.length);
+            const reduce = tolerance == null ? ValueMapReader.SIMPLIFY_TOLERANCE : tolerance;
+            const outer = reduce ? Simplify(traced[0], reduce) : traced[0];
+            const holes = traced.slice(1)
+                .map((hole) => (reduce ? Simplify(hole, reduce) : hole))
+                .filter((hole) => hole.length >= 4);
+            return {
+                Outer: this.Grid.RingToPoints(outer),
+                Holes: holes.map((hole) => this.Grid.RingToPoints(hole))
+            };
+        }
+        /**
+         * Walks the series in order, reporting only the ground each frame adds.
+         * Most frames add nothing, so onProgress is called for every frame while only the ones that grew come back.
+         */
+        NewAreas(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const times = this.Times;
+                const added = [];
+                let seen = null;
+                for (let index = 0; index < this.Length; index++) {
+                    const mask = yield this.CoveredMask({
+                        threshold: options.threshold,
+                        frame: index,
+                        minTexels: options.minTexels,
+                        excludeBaseline: options.excludeBaseline,
+                        source: options.source
+                    });
+                    const fresh = seen ? Combine(mask, seen, (left, right) => left && !right) : mask;
+                    seen = seen ? Combine(seen, mask, (left, right) => left || right) : mask;
+                    // Each area here sits inside one that already cleared the floor, so applying the
+                    // floor again would drop the thin edge that makes this frame new.
+                    const shapes = Count(fresh)
+                        ? this.ShapesOf(fresh, { minTexels: 1, tolerance: options.tolerance })
+                        : [];
+                    if (options.onProgress) {
+                        options.onProgress({
+                            Frame: index,
+                            Frames: this.Length,
+                            Time: times[index] || null,
+                            NewTexels: Count(fresh),
+                            Added: !!shapes.length
+                        });
+                    }
+                    if (shapes.length) {
+                        added.push({
+                            Frame: index,
+                            Time: times[index] || null,
+                            NewTexels: Count(fresh),
+                            Shapes: shapes,
+                            New: fresh,
+                            Cumulative: { Width: seen.Width, Height: seen.Height, Bits: seen.Bits.slice() }
+                        });
+                    }
+                }
+                return added;
+            });
+        }
+        /**
+         * The texels an Entity covers, from where its record says it is.
+         *
+         * The raster does not move, so this holds for the whole series and a caller reading every
+         * frame works it out once.
+         *
+         * Ask for geometry to use the Entity's own outline rather than the box around it.
+         */
+        TexelsOf(entity, useGeometry = false) {
+            if (useGeometry) {
+                const rings = RingsOfEntity(entity);
+                if (rings.length) {
+                    const hits = new Map();
+                    for (const ring of rings) {
+                        for (const texel of this.Grid.TexelsUnder(ring)) {
+                            hits.set(texel.Row + ":" + texel.Column, texel);
+                        }
+                    }
+                    const found = [];
+                    hits.forEach((texel) => found.push(texel));
+                    return found.sort((left, right) => left.Row - right.Row || left.Column - right.Column);
+                }
+            }
+            return this.Grid.TexelsIn(Bounds.FromEntity(entity));
+        }
+        /**
+         * Every value a frame holds over a set of texels, skipping the texels it never sampled.
+         *
+         * An unsampled texel decodes to the bottom of the archive's range, which reads as a real
+         * measurement rather than as an absence, so the coverage mask decides what is reported.
+         */
+        ReadingsAt(texels, frame) {
+            const readings = [];
+            for (const texel of texels || []) {
+                const at = texel.Row * frame.Width + texel.Column;
+                if (at < 0 || at >= frame.Covered.length || !frame.Covered[at]) {
+                    continue;
+                }
+                readings.push(frame.Values[at]);
+            }
+            return readings;
+        }
+        /**
+         * The highest value a frame holds over a set of texels, or null where it holds nothing.
+         *
+         * The highest rather than the middle one, because something spanning more than one texel is
+         * described by its worst part.
+         */
+        PeakAt(texels, frame = 0, source = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const readings = this.ReadingsAt(texels, yield this.Frame(frame, source));
+                return readings.length ? Math.max.apply(null, readings) : null;
+            });
+        }
+        /**
+         * The average value a frame holds over a set of texels, or null where it holds nothing.
+         * What something spanning several texels experienced overall, as against the worst part.
+         */
+        MeanAt(texels, frame = 0, source = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const readings = this.ReadingsAt(texels, yield this.Frame(frame, source));
+                return readings.length ? Sum(readings) / readings.length : null;
+            });
+        }
+        /**
+         * How the values over a mask are spread, for a caller reporting on an area.
+         */
+        ValuesAt(mask, frame) {
+            const selected = [];
+            for (let at = 0; at < mask.Bits.length; at++) {
+                if (mask.Bits[at] && frame.Covered[at]) {
+                    selected.push(frame.Values[at]);
+                }
+            }
+            if (!selected.length) {
+                return { Texels: 0 };
+            }
+            selected.sort((left, right) => left - right);
+            const middle = Math.floor(selected.length / 2);
+            return {
+                Texels: selected.length,
+                Peak: selected[selected.length - 1],
+                Mean: Sum(selected) / selected.length,
+                Median: selected.length % 2
+                    ? selected[middle]
+                    : (selected[middle - 1] + selected[middle]) / 2
+            };
+        }
+        /**
+         * The finest tile covering a position, or null when it falls outside every one of them.
+         *
+         * Tiles overlap, and the finer one is the better answer, so the last match wins over a list
+         * that is already sorted coarse first.
+         */
+        TileAt(longitude, latitude) {
+            let found = null;
+            for (const tile of this.Tiles) {
+                if (longitude >= tile.West && longitude <= tile.East
+                    && latitude >= tile.South && latitude <= tile.North) {
+                    found = tile;
+                }
+            }
+            return found;
+        }
+        /**
+         * One reading at one place, in both the delivered numbers and the source's own.
+         *
+         * Reads the single tile the position falls in rather than compositing the whole grid, which
+         * is what makes charting one point over a long series cheap.
+         */
+        SampleAt(longitude, latitude, frame = 0) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const tile = this.TileAt(longitude, latitude);
+                if (!tile) {
+                    return null;
+                }
+                const position = this.position(frame);
+                const times = this.Times;
+                const reading = {
+                    Longitude: longitude,
+                    Latitude: latitude,
+                    Frame: position,
+                    Time: times[position] || null,
+                    Units: this.Units,
+                    Texel: this.Grid.TexelAt(longitude, latitude),
+                    Covered: false,
+                    Value: null,
+                    SourceValue: null
+                };
+                const at = TexelIn(tile, longitude, latitude);
+                if (!at) {
+                    return reading;
+                }
+                const index = this.Tiles.indexOf(tile);
+                const values = yield this.tileLayer(index, ValueMapMetadata.LAYER_VALUE, position);
+                if (!values || !values.Values) {
+                    return reading;
+                }
+                const cell = at.Row * values.Width + at.Column;
+                if (!values.Covered[cell]) {
+                    return reading;
+                }
+                const value = values.Values[cell];
+                reading.Covered = true;
+                reading.Value = value;
+                reading.SourceValue = value;
+                if (this.Transform) {
+                    const shift = yield this.tileLayer(index, ValueMapMetadata.LAYER_VALUE_SHIFT);
+                    if (!shift || !shift.Values) {
+                        throw new Error(this.missingShift());
+                    }
+                    reading.SourceValue = shift.Covered[cell] ? value - shift.Values[cell] : null;
+                }
+                return reading;
+            });
+        }
+        /**
+         * Everything the archive knows about one place, for a caller inspecting a single point.
+         */
+        DetailsAt(longitude, latitude, frame = 0) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const reading = yield this.SampleAt(longitude, latitude, frame);
+                if (!reading) {
+                    return null;
+                }
+                const tile = this.TileAt(longitude, latitude);
+                const at = TexelIn(tile, longitude, latitude);
+                const position = this.Tiles.indexOf(tile);
+                return Object.assign({}, reading, {
+                    Attribute: this.Attribute,
+                    Label: this.Label,
+                    Dataset: this.Dataset,
+                    Frames: this.Length,
+                    Transform: this.Transform || null,
+                    VerticalDatum: this.VerticalDatum,
+                    Tile: {
+                        Level: tile.Level,
+                        TexelMetres: tile.TexelMetres,
+                        ResolutionX: tile.ResolutionX,
+                        ResolutionY: tile.ResolutionY,
+                        West: tile.West,
+                        East: tile.East,
+                        South: tile.South,
+                        North: tile.North
+                    },
+                    TileTexel: at,
+                    ValueMin: yield this.tileReading(position, ValueMapMetadata.LAYER_VALUE_MIN, at),
+                    ValueMax: yield this.tileReading(position, ValueMapMetadata.LAYER_VALUE_MAX, at),
+                    Shift: yield this.tileReading(position, ValueMapMetadata.LAYER_VALUE_SHIFT, at),
+                    Baseline: yield this.tileFlag(position, ValueMapMetadata.LAYER_BASELINE, at)
+                });
+            });
+        }
+        /**
+         * Every reading at one place over the whole series, in the order the times run.
+         */
+        SeriesAt(longitude, latitude) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const tile = this.TileAt(longitude, latitude);
+                if (!tile) {
+                    return [];
+                }
+                const at = TexelIn(tile, longitude, latitude);
+                const times = this.Times;
+                const position = this.Tiles.indexOf(tile);
+                const frames = yield this.tileSeries(position, ValueMapMetadata.LAYER_VALUE);
+                const shift = this.Transform
+                    ? yield this.tileLayer(position, ValueMapMetadata.LAYER_VALUE_SHIFT)
+                    : null;
+                if (this.Transform && (!shift || !shift.Values)) {
+                    throw new Error(this.missingShift());
+                }
+                return times.map((time, index) => {
+                    const reading = {
+                        Longitude: longitude,
+                        Latitude: latitude,
+                        Frame: index,
+                        Time: time,
+                        Units: this.Units,
+                        Texel: this.Grid.TexelAt(longitude, latitude),
+                        Covered: false,
+                        Value: null,
+                        SourceValue: null
+                    };
+                    const field = frames[index];
+                    if (!at || !field || !field.Values) {
+                        return reading;
+                    }
+                    const cell = at.Row * field.Width + at.Column;
+                    if (!field.Covered[cell]) {
+                        return reading;
+                    }
+                    reading.Covered = true;
+                    reading.Value = field.Values[cell];
+                    reading.SourceValue = field.Values[cell];
+                    if (shift) {
+                        reading.SourceValue = shift.Covered[cell]
+                            ? field.Values[cell] - shift.Values[cell]
+                            : null;
+                    }
+                    return reading;
+                });
+            });
+        }
+        /**
+         * What one frame holds over an Entity, in both the delivered numbers and the source's own.
+         */
+        SampleOf(entity, frame = 0, useGeometry = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const texels = this.TexelsOf(entity, useGeometry);
+                const times = this.Times;
+                const position = frame >= 0 ? frame : times.length + frame;
+                const summary = {
+                    Frame: position,
+                    Time: times[position] || null,
+                    Units: this.Units,
+                    Texels: texels.length,
+                    Covered: 0,
+                    Peak: null,
+                    Mean: null,
+                    SourcePeak: null,
+                    SourceMean: null
+                };
+                if (!texels.length) {
+                    return summary;
+                }
+                const readings = this.ReadingsAt(texels, yield this.Frame(position));
+                summary.Covered = readings.length;
+                if (readings.length) {
+                    summary.Peak = Math.max.apply(null, readings);
+                    summary.Mean = Sum(readings) / readings.length;
+                }
+                if (!this.Transform) {
+                    summary.SourcePeak = summary.Peak;
+                    summary.SourceMean = summary.Mean;
+                    return summary;
+                }
+                const sourceReadings = this.ReadingsAt(texels, yield this.Frame(position, true));
+                if (sourceReadings.length) {
+                    summary.SourcePeak = Math.max.apply(null, sourceReadings);
+                    summary.SourceMean = Sum(sourceReadings) / sourceReadings.length;
+                }
+                return summary;
+            });
+        }
+        /**
+         * What every frame holds over one Entity, for a caller charting a record through an event.
+         */
+        SeriesOf(entity, useGeometry = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const summaries = [];
+                for (let index = 0; index < this.Length; index++) {
+                    summaries.push(yield this.SampleOf(entity, index, useGeometry));
+                }
+                return summaries;
+            });
+        }
+        identity() {
+            return this.Metadata.Identity || {};
+        }
+        /*
+         * A frame index checked against the series, with a negative one counted from the end.
+         */
+        position(index) {
+            const frames = this.Length;
+            if (!frames) {
+                throw new Error("This value map has no frames.");
+            }
+            const at = index >= 0 ? index : frames + index;
+            if (at < 0 || at >= frames) {
+                throw new Error("Frame " + index + " is outside the " + frames
+                    + " this value map holds.");
+            }
+            return at;
+        }
+        /*
+         * One per-texel statistic over the whole series, in the archive's own units, or null.
+         */
+        statistic(name) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.statistics.has(name)) {
+                    return this.statistics.get(name);
+                }
+                const field = this.Layer(name) ? yield this.composite(name) : null;
+                this.statistics.set(name, field);
+                return field;
+            });
+        }
+        /*
+         * One layer drawn onto the composite grid from every tile that carries it.
+         *
+         * Nearest neighbour throughout: a texel is one mesh sample, and interpolating it with its
+         * neighbour produces a reading no cell ever reported.
+         */
+        composite(name, index) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const width = this.Grid.Width;
+                const height = this.Grid.Height;
+                const isMask = this.packing(name) === ValueMapMetadata.FORMAT_MASK;
+                const values = isMask ? null : new Float64Array(width * height);
+                const covered = new Uint8Array(width * height);
+                const ranges = this.Tiles.map((tile) => ValueMapMetadata.BytesOf(tile, name, index));
+                const rasters = yield this.decodeAll(ranges);
+                let drawn = false;
+                for (let at = 0; at < this.Tiles.length; at++) {
+                    const raster = rasters[at];
+                    if (!raster) {
+                        continue;
+                    }
+                    drawn = true;
+                    this.paste(this.Tiles[at], raster, name, values, covered);
+                }
+                if (!drawn) {
+                    return null;
+                }
+                return { Width: width, Height: height, Values: values, Covered: covered };
+            });
+        }
+        /*
+         * One tile's pixels written onto the composite grid, unpacked as they land.
+         */
+        paste(tile, raster, name, values, covered) {
+            const rect = ValueMapGrid.TileRect(tile, this.Extent, { Width: this.Grid.Width, Height: this.Grid.Height });
+            const range = this.range(name);
+            const format = this.packing(name);
+            const width = this.Grid.Width;
+            const height = this.Grid.Height;
+            for (let row = 0; row < rect.Height; row++) {
+                const target = rect.Top + row;
+                if (target < 0 || target >= height) {
+                    continue;
+                }
+                const sourceRow = Math.min(raster.Height - 1, Math.floor((row + 0.5) * raster.Height / rect.Height));
+                for (let column = 0; column < rect.Width; column++) {
+                    const across = rect.Left + column;
+                    if (across < 0 || across >= width) {
+                        continue;
+                    }
+                    const sourceColumn = Math.min(raster.Width - 1, Math.floor((column + 0.5) * raster.Width / rect.Width));
+                    const from = (sourceRow * raster.Width + sourceColumn) * 4;
+                    const to = target * width + across;
+                    if (raster.Data[from + 3] <= ValueMapMetadata.NO_DATA) {
+                        covered[to] = 0;
+                        if (values) {
+                            values[to] = 0;
+                        }
+                        continue;
+                    }
+                    covered[to] = 1;
+                    if (values) {
+                        values[to] = ValueMapMetadata.Decode(ValueMapMetadata.PackedAt(raster.Data, from, format), format, range);
+                    }
+                }
+            }
+        }
+        /*
+         * One tile's copy of a layer, unpacked, or null when that tile does not carry it.
+         *
+         * Kept per tile rather than composited, since a point sits in one tile and building the
+         * whole grid to read a single texel costs one image decode per tile in the archive.
+         */
+        tileLayer(position, name, index) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const key = position + ":" + name + ":" + (index == null ? "" : index);
+                if (this.tileLayers.has(key)) {
+                    const held = this.tileLayers.get(key);
+                    this.tileLayers.delete(key);
+                    this.tileLayers.set(key, held);
+                    return held;
+                }
+                const at = ValueMapMetadata.BytesOf(this.Tiles[position], name, index);
+                const rasters = yield this.decodeAll([at]);
+                const raster = rasters[0];
+                const field = raster
+                    ? Unpack(raster, this.packing(name), this.range(name))
+                    : null;
+                this.tileLayers.set(key, field);
+                Trim(this.tileLayers, ValueMapReader.TILE_CACHE);
+                return field;
+            });
+        }
+        /*
+         * One texel's number in a named layer of one tile, or null where the layer does not cover it.
+         */
+        tileReading(position, name, at) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!at || !this.Layer(name)) {
+                    return null;
+                }
+                const field = yield this.tileLayer(position, name);
+                if (!field || !field.Values) {
+                    return null;
+                }
+                const cell = at.Row * field.Width + at.Column;
+                return field.Covered[cell] ? field.Values[cell] : null;
+            });
+        }
+        /*
+         * Whether a mask layer flags one texel of one tile.
+         */
+        tileFlag(position, name, at) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!at || !this.Layer(name)) {
+                    return false;
+                }
+                const field = yield this.tileLayer(position, name);
+                if (!field) {
+                    return false;
+                }
+                return !!field.Covered[at.Row * field.Width + at.Column];
+            });
+        }
+        /*
+         * One tile's whole per-time series, unpacked, in one read of the blob.
+         *
+         * Kept out of the tile cache on purpose: a long series would evict everything else in it,
+         * and the caller walking a chart holds the result anyway.
+         */
+        tileSeries(position, name) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const tile = this.Tiles[position];
+                const ranges = this.Times.map((_time, index) => ValueMapMetadata.BytesOf(tile, name, index));
+                const rasters = yield this.decodeAll(ranges);
+                const format = this.packing(name);
+                const range = this.range(name);
+                return rasters.map((raster) => raster ? Unpack(raster, format, range) : null);
+            });
+        }
+        /*
+         * Every named slice decoded, over as few reads of the blob as the layout allows.
+         */
+        decodeAll(ranges) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const reads = ValueMapMetadata.PlanReads(ranges);
+                if (!reads.length) {
+                    return ranges.map(() => null);
+                }
+                const blocks = yield Promise.all(reads.map((read) => this.bytes(read.Offset, read.Length)));
+                return Promise.all(ranges.map((at) => {
+                    if (!at || !at.Length) {
+                        return Promise.resolve(null);
+                    }
+                    for (let index = 0; index < reads.length; index++) {
+                        const read = reads[index];
+                        if (at.Offset < read.Offset || at.Offset + at.Length > read.Offset + read.Length) {
+                            continue;
+                        }
+                        const from = at.Offset - read.Offset;
+                        return this.decoder(blocks[index].subarray(from, from + at.Length))
+                            .catch(() => null);
+                    }
+                    return Promise.resolve(null);
+                }));
+            });
+        }
+        /*
+         * How a named layer is packed, since a statistics layer can differ from the frames.
+         */
+        packing(name) {
+            const layer = this.Layer(name);
+            return (layer && layer.Format) || this.Format;
+        }
+        /*
+         * The range a named layer was quantised over, falling back to the frames' own.
+         */
+        range(name) {
+            return ValueMapMetadata.LayerRange(this.Metadata, name) || this.ValueRange;
+        }
+        /*
+         * A frame's delivered values as the source's own numbers.
+         *
+         * Nothing to undo is the common case and is not an error: an archive that declares no
+         * transform delivered the source's numbers untouched.
+         */
+        toSource(frame) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.Transform) {
+                    return frame;
+                }
+                const shift = yield this.ValueShift();
+                if (!shift || !shift.Values) {
+                    throw new Error(this.missingShift());
+                }
+                const values = new Float64Array(frame.Values.length);
+                const covered = new Uint8Array(frame.Covered.length);
+                for (let at = 0; at < values.length; at++) {
+                    // A texel the shift never sampled has no source reading to report, whatever the
+                    // frame holds.
+                    covered[at] = frame.Covered[at] && shift.Covered[at] ? 1 : 0;
+                    values[at] = frame.Values[at] - (shift.Covered[at] ? shift.Values[at] : 0);
+                }
+                return { Width: frame.Width, Height: frame.Height, Values: values, Covered: covered };
+            });
+        }
+        missingShift() {
+            return "This value map declares a " + this.Transform + " transform but publishes no "
+                + ValueMapMetadata.LAYER_VALUE_SHIFT + " layer, so the source's own numbers cannot be"
+                + " recovered.";
+        }
+    }
+    ValueMapReader.Reader = Reader;
+    function Open(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let file = params.file;
+            if (!file) {
+                if (!params.fileId) {
+                    throw new Error("A Client File, or a Client File ID, is required.");
+                }
+                const found = yield ClientFile.Get({ api: params.api, fileId: params.fileId });
+                file = found ? found.clientFile : null;
+            }
+            if (!file) {
+                throw new Error("Client File " + params.fileId + " was not found.");
+            }
+            return new Reader({
+                file: file,
+                bytes: params.bytes || SourceFor(file, params.blob, params.api),
+                decoder: params.decoder,
+                maxCompositeTexels: params.maxCompositeTexels,
+                extent: params.extent
+            });
+        });
+    }
+    ValueMapReader.Open = Open;
+    /**
+     * Where an archive's bytes come from: a blob already held, or ranged reads of the file's URL.
+     */
+    function SourceFor(file, blob, api) {
+        if (blob) {
+            const held = blob instanceof Uint8Array ? blob : new Uint8Array(blob);
+            return (offset, length) => Promise.resolve(held.subarray(offset, offset + length));
+        }
+        // The record's own URL where it carries one, since it may be a signed or CDN address that
+        // a reconstructed one would not match.
+        const url = file.URL || ClientFile.GetUrl({ api: api, fileId: file.ID });
+        return (offset, length) => __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(url, {
+                headers: { Range: "bytes=" + offset + "-" + (offset + length - 1) }
+            });
+            return new Uint8Array(yield response.arrayBuffer());
+        });
+    }
+    ValueMapReader.SourceFor = SourceFor;
+    /**
+     * Decodes a PNG where the runtime has an image decoder of its own.
+     *
+     * A browser has one. Node does not, and rather than pull an image library into a client library
+     * that mostly does not decode anything, a caller there passes their own.
+     */
+    ValueMapReader.DefaultDecoder = (bytes) => __awaiter(this, void 0, void 0, function* () {
+        const globals = typeof globalThis !== "undefined" ? globalThis : {};
+        if (typeof globals.createImageBitmap !== "function" || typeof globals.OffscreenCanvas !== "function") {
+            throw new Error("This runtime has no image decoder, so a value map's pixels cannot be"
+                + " read here. Pass Decoder to read them, or use the metadata surface, which needs"
+                + " no decoding.");
+        }
+        const blob = new globals.Blob([bytes], { type: "image/png" });
+        const bitmap = yield globals.createImageBitmap(blob);
+        try {
+            const canvas = new globals.OffscreenCanvas(bitmap.width, bitmap.height);
+            const context = canvas.getContext("2d");
+            context.drawImage(bitmap, 0, 0);
+            const pixels = context.getImageData(0, 0, bitmap.width, bitmap.height);
+            return { Width: bitmap.width, Height: bitmap.height, Data: pixels.data };
+        }
+        finally {
+            if (bitmap.close) {
+                bitmap.close();
+            }
+        }
+    });
+    // A ring needs three distinct corners and the repeat that closes it.
+    ValueMapReader.MIN_RING_POINTS = 4;
+    /**
+     * The disconnected areas in a mask, as 4-connected groups of texels.
+     */
+    function Components(mask, minTexels = 1) {
+        const width = mask.Width;
+        const height = mask.Height;
+        const seen = new Uint8Array(mask.Bits.length);
+        const found = [];
+        for (let start = 0; start < mask.Bits.length; start++) {
+            if (!mask.Bits[start] || seen[start]) {
+                continue;
+            }
+            seen[start] = 1;
+            const pending = [start];
+            const members = [];
+            while (pending.length) {
+                const at = pending.pop();
+                const row = Math.floor(at / width);
+                const column = at - row * width;
+                members.push({ Row: row, Column: column });
+                if (row > 0) {
+                    Visit(mask, seen, pending, at - width);
+                }
+                if (row < height - 1) {
+                    Visit(mask, seen, pending, at + width);
                 }
-                else if (geo.Polygon) {
-                    merged.Polygon = geo.Polygon;
+                if (column > 0) {
+                    Visit(mask, seen, pending, at - 1);
                 }
-            };
-            full.MultiGeometry.forEach(addToMerged);
-            return {
-                geometry: merged,
-                properties: properties
-            };
+                if (column < width - 1) {
+                    Visit(mask, seen, pending, at + 1);
+                }
+            }
+            if (members.length >= minTexels) {
+                found.push(members);
+            }
         }
-        // If there are many polygons but only 1 line and/or 1 point then we'll put those singles into the top-level.
-        // Eg: 5 polygons, 1 point, 1 line. That should be a single geometry.
-        if (countsPerType.Polygon > 1 && (countsPerType.LineString <= 1 && countsPerType.Point <= 1)) {
-            const semiMerged = {};
-            const addToSemiMerged = (geo) => {
-                if (geo.Point) {
-                    semiMerged.Point = geo.Point;
+        return found;
+    }
+    ValueMapReader.Components = Components;
+    /**
+     * The closed rings bounding a group of texels, in texel corner coordinates.
+     */
+    function Trace(members) {
+        const held = new Set();
+        for (const texel of members) {
+            held.add(texel.Row + ":" + texel.Column);
+        }
+        const edges = new Map();
+        const emit = (from, to) => {
+            const outgoing = edges.get(from);
+            if (outgoing) {
+                outgoing.push(to);
+            }
+            else {
+                edges.set(from, [to]);
+            }
+        };
+        const corner = (x, y) => x + ":" + y;
+        for (const texel of members) {
+            const row = texel.Row;
+            const column = texel.Column;
+            if (!held.has((row - 1) + ":" + column)) {
+                emit(corner(column, row), corner(column + 1, row));
+            }
+            if (!held.has(row + ":" + (column + 1))) {
+                emit(corner(column + 1, row), corner(column + 1, row + 1));
+            }
+            if (!held.has((row + 1) + ":" + column)) {
+                emit(corner(column + 1, row + 1), corner(column, row + 1));
+            }
+            if (!held.has(row + ":" + (column - 1))) {
+                emit(corner(column, row + 1), corner(column, row));
+            }
+        }
+        const rings = [];
+        const starts = [];
+        edges.forEach((_outgoing, from) => starts.push(from));
+        for (const start of starts) {
+            while ((edges.get(start) || []).length) {
+                const ring = [start];
+                let node = edges.get(start).pop();
+                let closed = true;
+                while (node !== start) {
+                    ring.push(node);
+                    const outgoing = edges.get(node);
+                    if (!outgoing || !outgoing.length) {
+                        closed = false;
+                        break;
+                    }
+                    node = outgoing.pop();
                 }
-                else if (geo.LineString) {
-                    semiMerged.LineString = geo.LineString;
+                if (closed) {
+                    ring.push(start);
+                    rings.push(ring.map(ToCorner));
                 }
-            };
-            semiMerged.MultiGeometry = full.MultiGeometry.filter(geo => geo.Polygon);
-            full.MultiGeometry.forEach(addToSemiMerged);
-            return {
-                geometry: semiMerged,
-                properties: properties
-            };
+            }
         }
-        // More than 1 of each, then return the full multi-geometry as-is.
-        return {
-            geometry: full,
-            properties: properties
-        };
+        return rings;
     }
-    Geometry.FromGeoJson = FromGeoJson;
-})(Geometry || (Geometry = {}));
-
-var Bounds;
-(function (Bounds) {
+    ValueMapReader.Trace = Trace;
     /**
-     * Calculates boundaries from entity.
-     * This will not use the entity's boundaries and instead calculate from geometry and location.
-     * @param entity
+     * A ring with its texel staircase reduced, by Ramer-Douglas-Peucker.
      */
-    function FromEntity(entity) {
-        const bounds = {
-            maxAltitude: null,
-            maxLatitude: null,
-            maxLongitude: null,
-            minAltitude: null,
-            minLatitude: null,
-            minLongitude: null
-        };
-        const points = [];
-        const assemblyLocation = Entity.GetValue({
-            entity: entity,
-            path: ["Bruce", "AssemblyLocation"]
-        });
-        if (assemblyLocation) {
-            points.push(assemblyLocation);
+    function Simplify(ring, tolerance) {
+        const points = ring.slice();
+        if (tolerance <= 0 || points.length < 4) {
+            return points;
         }
-        const location = Entity.GetValue({
-            entity: entity,
-            path: ["Bruce", "Location"]
-        });
-        if (location) {
-            points.push(location);
+        // Split before reducing: the algorithm anchors on the endpoints, and a closed ring's two
+        // endpoints are the same point, which would anchor on nothing.
+        const half = Math.floor(points.length / 2);
+        const front = Reduce(points.slice(0, half + 1), tolerance);
+        const back = Reduce(points.slice(half), tolerance);
+        const reduced = front.slice(0, front.length - 1).concat(back);
+        return reduced.length >= 4 ? reduced : points;
+    }
+    ValueMapReader.Simplify = Simplify;
+    /**
+     * How many texels a mask holds.
+     */
+    function Count(mask) {
+        let total = 0;
+        for (let at = 0; at < mask.Bits.length; at++) {
+            total += mask.Bits[at] ? 1 : 0;
         }
-        const geometry = Entity.GetValue({
-            entity: entity,
-            path: ["Bruce", "VectorGeometry"]
-        });
-        const processGeometry = (geometry, depth = 0) => {
-            if (!geometry || depth > 5) {
-                return;
+        return total;
+    }
+    ValueMapReader.Count = Count;
+    /**
+     * Two masks merged texel by texel.
+     */
+    function Combine(left, right, rule) {
+        const bits = new Uint8Array(left.Bits.length);
+        for (let at = 0; at < bits.length; at++) {
+            bits[at] = rule(!!left.Bits[at], !!right.Bits[at]) ? 1 : 0;
+        }
+        return { Width: left.Width, Height: left.Height, Bits: bits };
+    }
+    ValueMapReader.Combine = Combine;
+    /**
+     * A polygon geometry from an outer ring and its holes, ready to query Bruce with.
+     */
+    function Polygon(outer, holes) {
+        const toCartos = (ring) => ring.map((point) => ({
+            longitude: point.Longitude,
+            latitude: point.Latitude,
+            altitude: 0
+        }));
+        const rings = [{
+                LinearRing: Geometry.LineStrFromPoints(toCartos(outer)),
+                Facing: Geometry.EPolygonRingType.Boundaries
+            }];
+        for (const hole of holes || []) {
+            rings.push({
+                LinearRing: Geometry.LineStrFromPoints(toCartos(hole)),
+                Facing: Geometry.EPolygonRingType.Hole
+            });
+        }
+        return { Polygon: rings };
+    }
+    ValueMapReader.Polygon = Polygon;
+    /**
+     * An Entity's polygon rings, or nothing when its record carries no outline.
+     */
+    function RingsOfEntity(entity) {
+        const source = entity && entity.Bruce ? entity.Bruce : entity;
+        const geometry = (source && source.VectorGeometry) || {};
+        const rings = [];
+        for (const face of geometry.Polygon || []) {
+            if (!face || !face.LinearRing) {
+                continue;
             }
-            if (geometry.Point) {
-                points.push(...Geometry.ParsePoints(geometry.Point));
+            const points = Geometry.ParsePoints(face.LinearRing);
+            if (points.length >= 3) {
+                rings.push(points.map((point) => ({
+                    Longitude: point.longitude,
+                    Latitude: point.latitude
+                })));
             }
-            if (geometry.LineString) {
-                points.push(...Geometry.ParsePoints(geometry.LineString));
+        }
+        return rings;
+    }
+    ValueMapReader.RingsOfEntity = RingsOfEntity;
+    /*
+     * One decoded raster as its numbers and its own coverage, at the raster's own size.
+     */
+    function Unpack(raster, format, range) {
+        const isMask = format === ValueMapMetadata.FORMAT_MASK;
+        const values = isMask ? null : new Float64Array(raster.Width * raster.Height);
+        const covered = new Uint8Array(raster.Width * raster.Height);
+        for (let cell = 0; cell < covered.length; cell++) {
+            const from = cell * 4;
+            if (raster.Data[from + 3] <= ValueMapMetadata.NO_DATA) {
+                continue;
             }
-            if (geometry.Polygon) {
-                for (const ring of geometry.Polygon) {
-                    points.push(...Geometry.ParsePoints(ring.LinearRing));
-                }
+            covered[cell] = 1;
+            if (values) {
+                values[cell] = ValueMapMetadata.Decode(ValueMapMetadata.PackedAt(raster.Data, from, format), format, range);
             }
-            if (geometry.MultiGeometry) {
-                for (const multiGeometry of geometry.MultiGeometry) {
-                    processGeometry(multiGeometry, depth + 1);
-                }
+        }
+        return { Width: raster.Width, Height: raster.Height, Values: values, Covered: covered };
+    }
+    /*
+     * One neighbour queued, when it is in the mask and has not been reached yet.
+     */
+    function Visit(mask, seen, pending, at) {
+        if (mask.Bits[at] && !seen[at]) {
+            seen[at] = 1;
+            pending.push(at);
+        }
+    }
+    /*
+     * One run of a ring reduced against the line between its ends.
+     */
+    function Reduce(run, tolerance) {
+        if (run.length < 3) {
+            return run;
+        }
+        const first = run[0];
+        const last = run[run.length - 1];
+        const dx = last.X - first.X;
+        const dy = last.Y - first.Y;
+        const span = Math.sqrt(dx * dx + dy * dy);
+        let worstIndex = 0;
+        let worst = -1;
+        for (let index = 1; index < run.length - 1; index++) {
+            const point = run[index];
+            const distance = span === 0
+                ? Math.sqrt(Math.pow(point.X - first.X, 2) + Math.pow(point.Y - first.Y, 2))
+                : Math.abs(dy * point.X - dx * point.Y + last.X * first.Y - last.Y * first.X) / span;
+            if (distance > worst) {
+                worst = distance;
+                worstIndex = index;
+            }
+        }
+        if (worst <= tolerance) {
+            return [first, last];
+        }
+        const front = Reduce(run.slice(0, worstIndex + 1), tolerance);
+        return front.slice(0, front.length - 1).concat(Reduce(run.slice(worstIndex), tolerance));
+    }
+    /*
+     * A corner key back as its coordinates.
+     */
+    function ToCorner(key) {
+        const parts = key.split(":");
+        return { X: Number(parts[0]), Y: Number(parts[1]) };
+    }
+    /*
+     * The population standard deviation of a set of counts.
+     */
+    function Deviation(counts) {
+        if (!counts.length) {
+            return 0;
+        }
+        const mean = Sum(counts) / counts.length;
+        let total = 0;
+        for (const count of counts) {
+            total += Math.pow(count - mean, 2);
+        }
+        return Math.sqrt(total / counts.length);
+    }
+    function Sum(values) {
+        let total = 0;
+        for (const value of values) {
+            total += value;
+        }
+        return total;
+    }
+    /*
+     * Where a position lands inside one tile's own raster.
+     */
+    function TexelIn(tile, longitude, latitude) {
+        if (tile.East <= tile.West || tile.North <= tile.South) {
+            return null;
+        }
+        const width = tile.ResolutionX;
+        const height = tile.ResolutionY;
+        const column = Math.max(0, Math.min(width - 1, Math.floor((longitude - tile.West) / (tile.East - tile.West) * width)));
+        const row = Math.max(0, Math.min(height - 1, Math.floor((tile.North - latitude) / (tile.North - tile.South) * height)));
+        return { Row: row, Column: column };
+    }
+    /*
+     * The oldest entries dropped once a cache is over its limit.
+     */
+    function Trim(cache, limit) {
+        while (cache.size > limit) {
+            const oldest = cache.keys().next();
+            if (oldest.done) {
+                return;
             }
+            cache.delete(oldest.value);
+        }
+    }
+})(ValueMapReader || (ValueMapReader = {}));
+
+/**
+ * Generated value maps: what one declares, how to find it, and how to read it.
+ *
+ * A value map is a tiled raster of one attribute over a geographic area at a series of times, for
+ * example water depth over a region hour by hour.
+ *
+ * The archive is one blob of PNG tiles with a byte offset and length per layer per tile,
+ * and the block described below is the only account of what those bytes mean.
+ */
+var ClientFileValueMap;
+(function (ClientFileValueMap) {
+    const VALUE_MAP_SOURCE_PATH = "generation/Identity/EntityTypeSourceID";
+    const VALUE_MAP_ATTRIBUTE_PATH = "generation/Identity/Attribute";
+    const VALUE_MAP_ENTITY_TYPE_PATH = "generation/Identity/EntityTypeID";
+    const VALUE_MAP_DATASET_PATH = "generation/Identity/Dataset";
+    const VALUE_MAP_PAGE_SIZE = 300;
+    /*
+     * A query part as the list of values it narrows to.
+     */
+    function valueMapValues(value) {
+        if (value == null) {
+            return [];
+        }
+        return (Array.isArray(value) ? value : [value]).map((at) => String(at));
+    }
+    /*
+     * One Data path condition. Comma separated values become an SQL IN on the API side.
+     */
+    function valueMapRow(path, values) {
+        return {
+            column: ClientFile.Filter.EColumn.Data,
+            path: path,
+            rowOperator: ClientFile.Filter.ERowOperator.AND,
+            value: values.join(","),
+            includes: true,
+            valueOperator: values.length > 1 ? "in" : "equals",
+            rows: []
         };
-        processGeometry(geometry);
-        for (const point of points) {
-            if (bounds.maxLatitude == null || point.latitude > bounds.maxLatitude) {
-                bounds.maxLatitude = point.latitude;
+    }
+    /*
+     * Whether a file's published Identity satisfies every part of a query that was given.
+     */
+    function matchesValueMapQuery(file, query) {
+        var _a, _b;
+        const identity = (_b = (_a = file === null || file === void 0 ? void 0 : file.Data) === null || _a === void 0 ? void 0 : _a.generation) === null || _b === void 0 ? void 0 : _b.Identity;
+        if (!identity) {
+            return false;
+        }
+        const sources = valueMapValues(query.entityTypeSourceId);
+        // A source ID reaches us as a number from the API and as a string from a filter echo.
+        if (sources.length && sources.indexOf(String(identity.EntityTypeSourceID)) < 0) {
+            return false;
+        }
+        const attributes = valueMapValues(query.attribute);
+        if (attributes.length && attributes.indexOf(String(identity.Attribute)) < 0) {
+            return false;
+        }
+        if (query.entityTypeId && String(identity.EntityTypeID) !== String(query.entityTypeId)) {
+            return false;
+        }
+        if (query.dataset && String(identity.Dataset) !== String(query.dataset)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * The generated value maps matching a query, newest first.
+     */
+    function GetList(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { api, req: reqParams } = params;
+            if (!api) {
+                api = ENVIRONMENT.Api().GetBruceApi();
             }
-            if (bounds.maxLongitude == null || point.longitude > bounds.maxLongitude) {
-                bounds.maxLongitude = point.longitude;
+            const query = {
+                entityTypeSourceId: params.entityTypeSourceId,
+                attribute: params.attribute,
+                entityTypeId: params.entityTypeId,
+                dataset: params.dataset
+            };
+            const sources = valueMapValues(query.entityTypeSourceId);
+            const attributes = valueMapValues(query.attribute);
+            const rows = [];
+            if (sources.length) {
+                rows.push(valueMapRow(VALUE_MAP_SOURCE_PATH, sources));
             }
-            if (bounds.maxAltitude == null || point.altitude > bounds.maxAltitude) {
-                bounds.maxAltitude = point.altitude;
+            if (attributes.length) {
+                rows.push(valueMapRow(VALUE_MAP_ATTRIBUTE_PATH, attributes));
             }
-            if (bounds.minLatitude == null || point.latitude < bounds.minLatitude) {
-                bounds.minLatitude = point.latitude;
+            if (query.entityTypeId) {
+                rows.push(valueMapRow(VALUE_MAP_ENTITY_TYPE_PATH, [query.entityTypeId]));
             }
-            if (bounds.minLongitude == null || point.longitude < bounds.minLongitude) {
-                bounds.minLongitude = point.longitude;
+            if (query.dataset) {
+                rows.push(valueMapRow(VALUE_MAP_DATASET_PATH, [query.dataset]));
             }
-            if (bounds.minAltitude == null || point.altitude < bounds.minAltitude) {
-                bounds.minAltitude = point.altitude;
+            if (!rows.length) {
+                throw new Error("A value map query needs at least one of an Entity Type Source ID, an"
+                    + " attribute, an Entity Type ID or a dataset, since every generated file would"
+                    + " otherwise match.");
             }
-        }
-        return bounds;
+            const key = "client-file-value-map-list-" + JSON.stringify(query);
+            const cache = api.GetCacheItem(key, reqParams);
+            if (cache === null || cache === void 0 ? void 0 : cache.found) {
+                return cache.data;
+            }
+            const prom = (() => __awaiter(this, void 0, void 0, function* () {
+                const res = yield ClientFile.GetList({
+                    api,
+                    filter: {
+                        PageSize: params.pageSize || VALUE_MAP_PAGE_SIZE,
+                        PageIndex: 0,
+                        FilterRows: rows
+                    },
+                    req: reqParams
+                });
+                const generatedAt = (file) => { var _a, _b, _c; return String(((_c = (_b = (_a = file === null || file === void 0 ? void 0 : file.Data) === null || _a === void 0 ? void 0 : _a.generation) === null || _b === void 0 ? void 0 : _b.Identity) === null || _c === void 0 ? void 0 : _c.Generated) || ""); };
+                const revisionOf = (file) => { var _a, _b, _c; return Number(((_c = (_b = (_a = file === null || file === void 0 ? void 0 : file.Data) === null || _a === void 0 ? void 0 : _a.generation) === null || _b === void 0 ? void 0 : _b.Identity) === null || _c === void 0 ? void 0 : _c.Revision) || 0); };
+                const sorted = (res.clientFiles || [])
+                    .filter((file) => matchesValueMapQuery(file, query))
+                    .sort((left, right) => {
+                    const byTime = generatedAt(right).localeCompare(generatedAt(left));
+                    return byTime !== 0 ? byTime : revisionOf(right) - revisionOf(left);
+                });
+                return {
+                    files: sorted
+                };
+            }))();
+            api.SetCacheItem({
+                key,
+                value: prom,
+                req: reqParams
+            });
+            return prom;
+        });
     }
-    Bounds.FromEntity = FromEntity;
-})(Bounds || (Bounds = {}));
+    ClientFileValueMap.GetList = GetList;
+    /**
+     * The newest generated value map matching a query, or null.
+     */
+    function Get(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { files } = yield GetList(params);
+            return { file: files.length ? files[0] : null };
+        });
+    }
+    ClientFileValueMap.Get = Get;
+    // Reading what a published block declares, with no bytes fetched and no decoder needed.
+    ClientFileValueMap.Metadata = ValueMapMetadata;
+    // Placing the raster on the world: texels, extents, rings and the composite arithmetic.
+    ClientFileValueMap.Grid = ValueMapGrid;
+    /**
+     * A value map read from a Client File. See ValueMapReader.Open.
+     */
+    function Open(params) {
+        return ValueMapReader.Open(params);
+    }
+    ClientFileValueMap.Open = Open;
+    /**
+     * Where an archive's bytes come from. See ValueMapReader.SourceFor.
+     */
+    function SourceFor(file, blob, api) {
+        return ValueMapReader.SourceFor(file, blob, api);
+    }
+    ClientFileValueMap.SourceFor = SourceFor;
+    /**
+     * Decodes a PNG where the runtime has an image decoder of its own.
+     */
+    function DefaultDecoder(bytes) {
+        return ValueMapReader.DefaultDecoder(bytes);
+    }
+    ClientFileValueMap.DefaultDecoder = DefaultDecoder;
+    /**
+     * One archive's reader, for a caller holding a record and its bytes already.
+     */
+    function NewReader(params) {
+        return new ValueMapReader.Reader(params);
+    }
+    ClientFileValueMap.NewReader = NewReader;
+})(ClientFileValueMap || (ClientFileValueMap = {}));
 
 var Camera;
 (function (Camera) {
@@ -15062,6 +17350,24 @@ var ExportCsv;
     }
 })(ExportCsv || (ExportCsv = {}));
 
+var ExportNsx;
+(function (ExportNsx) {
+    /**
+     * Starts a whole-account NSX backup export job.
+     * The generated NSX file is stored in the account's configured backup file store.
+     */
+    function AccountBackup(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { api, req: reqParams } = params !== null && params !== void 0 ? params : {};
+            if (!api) {
+                api = ENVIRONMENT.Api().GetBruceApi();
+            }
+            return api.POST("export/nsx/accountBackup", {}, Api.PrepReqParams(reqParams));
+        });
+    }
+    ExportNsx.AccountBackup = AccountBackup;
+})(ExportNsx || (ExportNsx = {}));
+
 var ExportUsd;
 (function (ExportUsd) {
     function Export(params) {
@@ -20955,7 +23261,7 @@ var UrlUtils;
 })(UrlUtils || (UrlUtils = {}));
 
 // This is updated with the package.json version on build.
-const VERSION = "7.1.87";
+const VERSION = "7.1.89";
 
-export { VERSION, Account, AccountAudit, AccountConcept, AccountFeatures, AccountInvite, AccountLimits, AccountTemplate, AccountType, AnnDocument, AbstractApi, Api, ApiGetters, BruceApi, GlobalApi, GuardianApi, Assembly, Calculator, ChangeSet, ClientFile, Bounds, BruceEvent, BruceVariable, CacheControl, Camera, Cartes, Carto, Color, DelayQueue, GeoJson, Geometry, LRUCache, UTC, CustomForm, DashboardView, DataFeed, DataLab, DataLabGroup, DataSource, DataTransform, Comment, Entity, EntityAttachment, EntityAttachmentType, EntityAttribute, EntityComment, EntityCoords, EntityHistoricData, EntityLink, EntityLod, EntityLodCategory, EntityRelation, EntityRelationType, EntitySource, EntityTableView, EntityTag, EntityType, EntityTypeRelation, EntityTypeTrigger, Ontology, OntologyDocument, ENVIRONMENT, ExportBrz, ExportCsv, ExportUsd, Hexbin, ImportAssembly, ImportCad, ImportCsv, ImportGeoJson, ImportJson, ImportKml, ImportLcc, ImportedFile, Uploader, Markup, UIMarkup, NAVIGATOR_CHAT_EVENT_ENTITY_HIGHLIGHT_APPLIED, NAVIGATOR_CHAT_EVENT_SCENE_CONTEXT_PREFETCHED, NavigatorChatClient, NavigatorMcpWebSocketClient, Plugin, PluginAiTool, ProgramKey, MenuItem, ProjectView, ProjectViewBookmark, ProjectViewBookmarkGroup, ProjectViewLegacy, ProjectViewLegacyBookmark, ProjectViewLegacyTile, ProjectViewTile, ZoomControl, Scenario, HostingLocation, MessageBroker, PendingAction, RecordChangeFeed, Style, Tileset, Tracking, Permission, Session, User, UserGroup, UserMfaMethod, EncryptUtils, MathUtils, ObjectUtils, PathUtils, UrlUtils };
+export { VERSION, Account, AccountAudit, AccountConcept, AccountFeatures, AccountInvite, AccountLimits, AccountTemplate, AccountType, AnnDocument, AbstractApi, Api, ApiGetters, BruceApi, GlobalApi, GuardianApi, Assembly, Calculator, ChangeSet, ClientFile, ClientFileValueMap, Bounds, BruceEvent, BruceVariable, CacheControl, Camera, Cartes, Carto, Color, DelayQueue, GeoJson, Geometry, LRUCache, UTC, CustomForm, DashboardView, DataFeed, DataLab, DataLabGroup, DataSource, DataTransform, Comment, Entity, EntityAttachment, EntityAttachmentType, EntityAttribute, EntityComment, EntityCoords, EntityHistoricData, EntityLink, EntityLod, EntityLodCategory, EntityRelation, EntityRelationType, EntitySource, EntityTableView, EntityTag, EntityType, EntityTypeRelation, EntityTypeTrigger, Ontology, OntologyDocument, ENVIRONMENT, ExportBrz, ExportCsv, ExportNsx, ExportUsd, Hexbin, ImportAssembly, ImportCad, ImportCsv, ImportGeoJson, ImportJson, ImportKml, ImportLcc, ImportedFile, Uploader, Markup, UIMarkup, NAVIGATOR_CHAT_EVENT_ENTITY_HIGHLIGHT_APPLIED, NAVIGATOR_CHAT_EVENT_SCENE_CONTEXT_PREFETCHED, NavigatorChatClient, NavigatorMcpWebSocketClient, Plugin, PluginAiTool, ProgramKey, MenuItem, ProjectView, ProjectViewBookmark, ProjectViewBookmarkGroup, ProjectViewLegacy, ProjectViewLegacyBookmark, ProjectViewLegacyTile, ProjectViewTile, ZoomControl, Scenario, HostingLocation, MessageBroker, PendingAction, RecordChangeFeed, Style, Tileset, Tracking, Permission, Session, User, UserGroup, UserMfaMethod, EncryptUtils, MathUtils, ObjectUtils, PathUtils, UrlUtils };
 //# sourceMappingURL=bruce-models.es5.js.map