bruce-cesium 7.2.2 → 7.2.3

package/dist/bruce-cesium.umd.js

@@ -40286,40 +40286,222 @@
         });
     }
 
-    var TextureFrameSeriesAnimator;
     (function (TextureFrameSeriesAnimator) {
-        // Values are measured up from the ground beneath them.
-        TextureFrameSeriesAnimator.QUANTITY_THICKNESS = "thickness";
-        // Values are heights against a vertical datum, so they need that datum to be placed.
-        TextureFrameSeriesAnimator.QUANTITY_ELEVATION = "elevation";
         TextureFrameSeriesAnimator.LAYOUT_TILES = "tiles";
+        // The only generation this renderer draws. Anything else is refused rather than half read: the
+        // shapes differ enough that a partial reading produces a plausible wrong surface, which is worse
+        // than an empty one.
+        TextureFrameSeriesAnimator.SUPPORTED_VERSION = 3;
+        // Value in R at 8 bits, or high in R and low in G at 16.
+        TextureFrameSeriesAnimator.FORMAT_U8 = "u8";
+        TextureFrameSeriesAnimator.FORMAT_RG16 = "rg16";
+        // Declared as a field with one value, so a second mode can be added later without an absent
+        // Encoding having to mean anything.
+        TextureFrameSeriesAnimator.ENCODING_ABSOLUTE = "absolute";
+        TextureFrameSeriesAnimator.LAYER_VALUE = "Value";
+        TextureFrameSeriesAnimator.LAYER_VALUE_MIN = "ValueMin";
+        TextureFrameSeriesAnimator.LAYER_VALUE_MAX = "ValueMax";
+        TextureFrameSeriesAnimator.LAYER_BASELINE = "Baseline";
+        // The per-texel correction that was applied, published only on an archive that was transformed.
+        TextureFrameSeriesAnimator.LAYER_VALUE_SHIFT = "ValueShift";
         /**
-         * The generator that produced an archive, for telling a stale one from a current one.
+         * Turns a published value map into the flat shape this renderer works in, or null when it cannot be drawn.
+         * @param published the archive's Data.generation
+         */
+        function Adapt(published) {
+            if (!published || published.Version !== TextureFrameSeriesAnimator.SUPPORTED_VERSION) {
+                const found = published && published.Version != null ? published.Version : "none";
+                const at = published && published.Identity ? published.Identity.Generated : undefined;
+                // In theory should be no files.
+                console.warn("bruce-cesium: value map version " + found + " is not supported (this build reads "
+                    + TextureFrameSeriesAnimator.SUPPORTED_VERSION + "), so nothing will be drawn for it."
+                    + (at ? " The archive was generated at " + at + " and needs regenerating." : ""));
+                return null;
+            }
+            const geometry = published.Geometry || {};
+            const tiles = published.Tiles || [];
+            if (geometry.Layout !== TextureFrameSeriesAnimator.LAYOUT_TILES || tiles.length === 0) {
+                const at = published.Identity ? published.Identity.Generated : undefined;
+                console.warn("bruce-cesium: value map declares no tiles, so nothing will be drawn for it."
+                    + (at ? " The archive was generated at " + at + " and needs regenerating." : ""));
+                return null;
+            }
+            const value = published.Value || {};
+            if (value.Encoding && value.Encoding !== TextureFrameSeriesAnimator.ENCODING_ABSOLUTE) {
+                const at = published.Identity ? published.Identity.Generated : undefined;
+                console.warn("bruce-cesium: value map encoding " + value.Encoding + " is not supported"
+                    + " (this build reads " + TextureFrameSeriesAnimator.ENCODING_ABSOLUTE + "), so nothing will be drawn for it."
+                    + (at ? " The archive was generated at " + at + " and needs regenerating." : ""));
+                return null;
+            }
+            const series = published.Series || {};
+            const layerRange = declaredRange(published, TextureFrameSeriesAnimator.LAYER_VALUE_MIN);
+            const flat = {
+                Frames: [],
+                ValueMin: value.Min,
+                ValueMax: value.Max,
+                Format: value.Format || TextureFrameSeriesAnimator.FORMAT_U8,
+                Encoding: value.Encoding || TextureFrameSeriesAnimator.ENCODING_ABSOLUTE,
+                Units: value.Units,
+                West: geometry.West,
+                East: geometry.East,
+                South: geometry.South,
+                North: geometry.North,
+                ResolutionX: geometry.ResolutionX,
+                ResolutionY: geometry.ResolutionY,
+                PixelPlacement: geometry.PixelPlacement,
+                Times: series.Times,
+                ExtremesValueMin: layerRange ? layerRange.min : undefined,
+                ExtremesValueMax: layerRange ? layerRange.max : undefined,
+                // The delivered values are what gets drawn. What the source called them, and any shift
+                // applied on the way, travel for labels and analysis rather than for placement.
+                SourceVerticalDatum: published.ValueSource ? published.ValueSource.VerticalDatum : undefined,
+                Transform: published.ValueSource ? published.ValueSource.Transform : undefined,
+                SourceUnits: published.ValueSource ? published.ValueSource.Units : undefined,
+                SourceValueMin: published.ValueSource ? published.ValueSource.Min : undefined,
+                SourceValueMax: published.ValueSource ? published.ValueSource.Max : undefined
+            };
+            flat.Tiles = tiles.map((tile) => adaptTile(tile, series.Times));
+            // The coarsest tile covers the whole extent, so it is what a caller wanting one time list reads.
+            flat.Frames = flat.Tiles[0].Frames;
+            warnIfUnshifted(published, flat);
+            return flat;
+        }
+        TextureFrameSeriesAnimator.Adapt = Adapt;
+        /*
+         * Says so when an archive's heights are not on the ellipsoid they will be drawn against.
+         */
+        function warnIfUnshifted(published, flat) {
+            const datum = flat.SourceVerticalDatum;
+            if (!datum || datum === TextureFrameSeriesAnimator.DATUM_ELLIPSOIDAL || flat.Transform) {
+                return;
+            }
+            const at = published.Identity ? published.Identity.Generated : undefined;
+            console.warn("bruce-cesium: value map heights are in " + datum + " and report no transform, so"
+                + " they are not ellipsoidal and will draw at the wrong height when placed absolutely."
+                + (at ? " The archive was generated at " + at + " and needs regenerating with the shift"
+                    + " applied." : ""));
+        }
+        /*
+         * The Min and Max a named layer declares, since a statistics layer is encoded over the true data
+         * range rather than over the frames' own.
+         */
+        function declaredRange(published, name) {
+            const layers = published.Layers || [];
+            for (const layer of layers) {
+                if (layer.Name === name && typeof layer.Min === "number" && typeof layer.Max === "number") {
+                    return { min: layer.Min, max: layer.Max };
+                }
+            }
+            return null;
+        }
+        /*
+         * One tile, with its per-time value rasters lined up against the shared time list.
+         */
+        function adaptTile(tile, times) {
+            const layers = tile.Layers || {};
+            const perTime = layers[TextureFrameSeriesAnimator.LAYER_VALUE] || [];
+            const frames = perTime.map((entry, index) => ({
+                Timestamp: times && times[index] ? times[index] : "",
+                ByteOffset: entry.Bytes.Offset,
+                ByteLength: entry.Bytes.Length
+            }));
+            return {
+                Level: tile.Level,
+                X: tile.X,
+                Y: tile.Y,
+                West: tile.West,
+                East: tile.East,
+                South: tile.South,
+                North: tile.North,
+                TexelMetres: tile.TexelMetres,
+                ResolutionX: tile.ResolutionX,
+                ResolutionY: tile.ResolutionY,
+                Frames: frames,
+                Floor: single(layers[TextureFrameSeriesAnimator.LAYER_VALUE_MIN]),
+                Ceiling: single(layers[TextureFrameSeriesAnimator.LAYER_VALUE_MAX]),
+                BaselineMask: single(layers[TextureFrameSeriesAnimator.LAYER_BASELINE])
+            };
+        }
+        function single(layer) {
+            if (!layer || !layer.Bytes) {
+                return undefined;
+            }
+            return { ByteOffset: layer.Bytes.Offset, ByteLength: layer.Bytes.Length };
+        }
+        /**
+         * How to turn a delivered value into the number the source published, or null when the archive
+         * does not say enough to do it.
+         * @param metadata the archive's Data.generation
+         */
+        function SourceMap(metadata) {
+            if (!metadata) {
+                return null;
+            }
+            const { ValueMin, ValueMax, SourceValueMin, SourceValueMax } = metadata;
+            if (typeof ValueMin !== "number" || typeof ValueMax !== "number"
+                || typeof SourceValueMin !== "number" || typeof SourceValueMax !== "number") {
+                return null;
+            }
+            const delivered = ValueMax - ValueMin;
+            // A single delivered value describes no line, so all that can be recovered is where it sits.
+            const scale = delivered !== 0 ? (SourceValueMax - SourceValueMin) / delivered : 1;
+            return { scale, offset: SourceValueMin - ValueMin * scale };
+        }
+        TextureFrameSeriesAnimator.SourceMap = SourceMap;
+        /**
+         * A delivered value in the source's own terms, or unchanged when it cannot be turned back.
+         * @param map from SourceMap(), null when the archive does not say enough
+         */
+        function ToSource(map, value) {
+            return map ? value * map.scale + map.offset : value;
+        }
+        TextureFrameSeriesAnimator.ToSource = ToSource;
+        /**
+         * Whether the archive's frames carry a 16 bit value packed across R and G.
          *
-         * Read the version rather than sniffing for fields: an archive can legitimately omit Tiles or
-         * GeoidSeparation and still be current, so their absence says nothing about its age.
+         * Every consumer that reads a texel has to ask: taking R alone from a packed frame yields a
+         * plausible surface quantised to 255 steps of the full range rather than an obvious failure.
          * @param metadata the archive's Data.generation
          */
-        function GeneratorVersion(metadata) {
-            if (!metadata || typeof metadata.GeneratorVersion !== "number") {
-                return 1;
+        function IsPackedValue(metadata) {
+            return Boolean(metadata && metadata.Format === TextureFrameSeriesAnimator.FORMAT_RG16);
+        }
+        TextureFrameSeriesAnimator.IsPackedValue = IsPackedValue;
+        /**
+         * The normalised 0 to 1 value at a texel, from whichever format the archive packed it in.
+         * @param metadata the archive's Data.generation
+         * @param pixels untinted RGBA value pixels
+         * @param at index of the texel's red channel
+         */
+        function NormalisedAt(metadata, pixels, at) {
+            if (IsPackedValue(metadata)) {
+                return (pixels[at] * 256 + pixels[at + 1]) / 65535;
             }
-            return metadata.GeneratorVersion;
+            return pixels[at] / 255;
         }
-        TextureFrameSeriesAnimator.GeneratorVersion = GeneratorVersion;
+        TextureFrameSeriesAnimator.NormalisedAt = NormalisedAt;
+        // Values already sit on the ellipsoid Cesium measures against, so nothing is added to place them.
+        TextureFrameSeriesAnimator.DATUM_ELLIPSOIDAL = "WGS84";
         /**
-         * Whether an archive is an adaptive pyramid rather than one raster.
+         * Whether the values are heights against a vertical datum rather than a thickness.
+         *
+         * A thickness rises from wherever the polygon sits and a height already knows where it belongs, so
+         * this is what decides whether the polygon's own altitude may be added underneath it.
          * @param metadata the archive's Data.generation
          */
-        function IsTiledLayout(metadata) {
-            return (Boolean(metadata && metadata.Layout === TextureFrameSeriesAnimator.LAYOUT_TILES &&
-                metadata.Tiles && metadata.Tiles.length > 0));
-        }
-        TextureFrameSeriesAnimator.IsTiledLayout = IsTiledLayout;
-        // Frames carry the value as the source reported it.
-        TextureFrameSeriesAnimator.MEASURE_ABSOLUTE = "absolute";
-        // Frames carry the value minus each cell's own minimum over the series.
-        TextureFrameSeriesAnimator.MEASURE_ANOMALY = "anomaly";
+        function IsDatumHeight(metadata) {
+            return Boolean(metadata && metadata.SourceVerticalDatum);
+        }
+        TextureFrameSeriesAnimator.IsDatumHeight = IsDatumHeight;
+        /**
+         * The archive's tiles, which Adapt() guarantees are present.
+         * @param metadata the archive's Data.generation
+         */
+        function TilesOf(metadata) {
+            return (metadata && metadata.Tiles) || [];
+        }
+        TextureFrameSeriesAnimator.TilesOf = TilesOf;
         /**
          * Turns a value in the attribute's own units into the 0 to 1 position the ramp is indexed by.
          *
@@ -40338,44 +40520,18 @@
             return Math.min(1, Math.max(0, (value - lo) / span));
         }
         TextureFrameSeriesAnimator.NormalisePosition = NormalisePosition;
-        /**
-         * Whether the frames are a departure from each cell's own normal rather than a raw reading.
-         *
-         * Worth asking before labelling anything: the two measures need different words for the same
-         * number, and calling an anomaly "water depth" is a worse error than the coarse ramp it replaced.
-         * @param metadata the archive's Data.generation
-         */
-        function IsAnomalyMeasure(metadata) {
-            return Boolean(metadata && metadata.Measure === TextureFrameSeriesAnimator.MEASURE_ANOMALY);
-        }
-        TextureFrameSeriesAnimator.IsAnomalyMeasure = IsAnomalyMeasure;
-        /**
-         * How much the value moves anywhere in the series, in source units.
-         *
-         * Falls back to the published range, which is the right answer for an anomaly archive (its range
-         * IS the movement) and the only available one for an archive predating AnomalyMax.
-         * @param metadata the archive's Data.generation
-         */
-        function MovingRange(metadata) {
-            if (!metadata) {
-                return undefined;
-            }
-            if (typeof metadata.AnomalyMax === "number" && metadata.AnomalyMax > 0) {
-                return metadata.AnomalyMax;
-            }
-            if (typeof metadata.ValueMin === "number" && typeof metadata.ValueMax === "number") {
-                return Math.abs(metadata.ValueMax - metadata.ValueMin);
-            }
-            return undefined;
-        }
-        TextureFrameSeriesAnimator.MovingRange = MovingRange;
         /**
          * Detects whether a ClientFile's `Data.generation` metadata describes a frame archive rather than a single static image,
          * so a caller can decide whether to construct an Animator or fall back to the existing static-texture path.
-         * @param data ClientFile.Data (the `IFile.Data` field), as returned by ClientFile.Get().
+         * @param data ClientFile.Data
          */
         function IsFrameArchiveMetadata(data) {
-            return Boolean(data && data.generation && Array.isArray(data.generation.Frames) && data.generation.Frames.length > 0);
+            const generation = data && data.generation;
+            if (!generation) {
+                return false;
+            }
+            return (typeof generation.Version === "number" ||
+                (Array.isArray(generation.Frames) && generation.Frames.length > 0));
         }
         TextureFrameSeriesAnimator.IsFrameArchiveMetadata = IsFrameArchiveMetadata;
         // First resolvable static number out of a calculator field list, since that is all a border needs.
@@ -40421,10 +40577,27 @@
         TextureFrameSeriesAnimator.AppearanceSignature = AppearanceSignature;
         const MAX_COMPOSITE_TEXELS = 2048;
         const VALUE_DILATE_PASSES = 2;
+        /*
+         * Rewrites a packed 16 bit value as the 8 bit grey the colour ramps index on.
+         *
+         * All three channels, since a ramp is free to read any of them and a leftover low byte in G would
+         * show up as a green cast on the one that reads them all.
+         */
+        function flattenPacked(pixels, packed) {
+            if (!packed) {
+                return;
+            }
+            for (let i = 0; i < pixels.length; i += 4) {
+                const grey = Math.round((pixels[i] * 256 + pixels[i + 1]) / 65535 * 255);
+                pixels[i] = grey;
+                pixels[i + 1] = grey;
+                pixels[i + 2] = grey;
+            }
+        }
         /*
          * Bleeds covered values outward into uncovered texels, leaving alpha untouched.
          */
-        function dilateValues(value, width, height, passes) {
+        function dilateValues(value, width, height, passes, packed) {
             const texels = width * height;
             const filled = new Uint8Array(texels);
             for (let p = 0; p < texels; p++) {
@@ -40448,15 +40621,25 @@
                                 if (nx < 0 || ny < 0 || nx >= width || ny >= height || !wasFilled[ny * width + nx]) {
                                     continue;
                                 }
-                                sum += source[(ny * width + nx) * 4];
+                                const at = (ny * width + nx) * 4;
+                                // Averaged as a value rather than per byte: averaging a packed low byte
+                                // on its own wraps at every 256th step and speckles the bled edge.
+                                sum += packed ? source[at] * 256 + source[at + 1] : source[at];
                                 hits++;
                             }
                         }
                         if (hits > 0) {
                             const v = Math.round(sum / hits);
-                            value[p * 4] = v;
-                            value[p * 4 + 1] = v;
-                            value[p * 4 + 2] = v;
+                            if (packed) {
+                                value[p * 4] = (v >> 8) & 255;
+                                value[p * 4 + 1] = v & 255;
+                                value[p * 4 + 2] = 0;
+                            }
+                            else {
+                                value[p * 4] = v;
+                                value[p * 4 + 1] = v;
+                                value[p * 4 + 2] = v;
+                            }
                             filled[p] = 1;
                         }
                     }
@@ -40494,7 +40677,6 @@
                 // forcing Cesium to re-upload the texture only when something changed.
                 this.pool = [document.createElement("canvas"), document.createElement("canvas")];
                 this.poolIdx = 0;
-                this.scratch = null;
                 this.valueDims = null;
                 this.presentVersion = 0;
                 this.extremesLoad = null;
@@ -40517,7 +40699,7 @@
                 this.highColor = (mask && BModels.Color.ColorFromStr(mask.maxColor)) || DEFAULT_HIGH_COLOR;
                 // Positions are authored in the attribute's units and normalised once here, so the
                 // per-pixel loop stays a comparison against 0 to 1 like the two-colour path.
-                const points = mask === null || mask === void 0 ? void 0 : mask.points;
+                const points = mask && mask.points;
                 this.rampStops = (points && points.length > 0)
                     ? points.map((p) => ({
                         position: NormalisePosition(options.metadata, p.position),
@@ -40543,9 +40725,8 @@
                 this.produceValueCanvas = Boolean(options.produceValueCanvas);
                 this.metadata = options.metadata;
                 this.drapeExtent = options.drapeExtent;
-                this.tiles = IsTiledLayout(options.metadata) ? options.metadata.Tiles : undefined;
-                this.baselineMaskEntry = options.baselineMask || null;
-                this.maskBaseline = (_c = options.maskBaseline) !== null && _c !== void 0 ? _c : Boolean(options.baselineMask);
+                this.tiles = TilesOf(options.metadata);
+                this.maskBaseline = (_c = options.maskBaseline) !== null && _c !== void 0 ? _c : this.tiles.some((tile) => Boolean(tile.BaselineMask));
                 this.valueCanvas = this.produceValueCanvas ? document.createElement("canvas") : null;
                 this.driveMaterial = options.driveMaterial !== false;
                 this.originalMaterial = options.entity.polygon.material;
@@ -40721,32 +40902,20 @@
             }
             async fetchAndTint(idx) {
                 const tiles = this.tiles;
-                let buffer;
-                let span = 0;
-                if (tiles) {
-                    // Every tile's frame for one timestep sits contiguously, because the generator writes
-                    // frame major. So a tiled frame is still ONE range request, not one per tile.
-                    let lo = Number.MAX_SAFE_INTEGER;
-                    let hi = 0;
-                    for (const tile of tiles) {
-                        const at = tile.Frames[idx];
-                        if (!at) {
-                            continue;
-                        }
-                        lo = Math.min(lo, at.ByteOffset);
-                        hi = Math.max(hi, at.ByteOffset + at.ByteLength);
+                // Every tile's frame for one timestep sits contiguously, because the generator writes
+                // frame major. So a tiled frame is still ONE range request, not one per tile.
+                let lo = Number.MAX_SAFE_INTEGER;
+                let hi = 0;
+                for (const tile of tiles) {
+                    const at = tile.Frames[idx];
+                    if (!at) {
+                        continue;
                     }
-                    span = lo;
-                    const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${lo}-${hi - 1}` } });
-                    buffer = await response.arrayBuffer();
-                }
-                else {
-                    const entry = this.frames[idx];
-                    const start = entry.ByteOffset;
-                    const end = entry.ByteOffset + entry.ByteLength - 1;
-                    const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${start}-${end}` } });
-                    buffer = await response.arrayBuffer();
+                    lo = Math.min(lo, at.ByteOffset);
+                    hi = Math.max(hi, at.ByteOffset + at.ByteLength);
                 }
+                const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${lo}-${hi - 1}` } });
+                const buffer = await response.arrayBuffer();
                 if (this.disposed) {
                     return;
                 }
@@ -40756,9 +40925,7 @@
                 if (this.disposed) {
                     return;
                 }
-                const decoded = tiles
-                    ? await this.composeTiles(tiles, idx, buffer, span)
-                    : await this.decodeAndTint(buffer);
+                const decoded = await this.composeTiles(tiles, idx, buffer, lo);
                 if (this.disposed) {
                     return;
                 }
@@ -40769,26 +40936,6 @@
                     this.beginCrossfadeTo(idx);
                 }
             }
-            /**
-             * Decodes one frame's raw PNG bytes (as returned by a Range GET) and applies the grayscale color mask.
-             */
-            async decodeAndTint(buffer) {
-                const blob = new Blob([buffer], { type: "image/png" });
-                const objectUrl = URL.createObjectURL(blob);
-                let image;
-                try {
-                    image = await loadImage(objectUrl);
-                }
-                finally {
-                    URL.revokeObjectURL(objectUrl);
-                }
-                const canvas = document.createElement("canvas");
-                canvas.width = image.width;
-                canvas.height = image.height;
-                const ctx = canvas.getContext("2d");
-                ctx.drawImage(image, 0, 0);
-                return this.tint(ctx.getImageData(0, 0, canvas.width, canvas.height));
-            }
             /*
              * Draws every tile of one frame into a single raster covering the drape extent.
              */
@@ -40861,6 +41008,10 @@
                 // Copied before tinting: the ramp is a lerp between two colours, so the value cannot be
                 // recovered from the tinted pixels afterwards.
                 const valuePixels = this.produceValueCanvas ? new Uint8ClampedArray(imageData.data) : undefined;
+                // The ramp indexes on R as an 8 bit grey, so a packed frame is flattened to one here
+                // rather than teaching every ramp function a second format.
+                // The copy above keeps the packed pair, which is what displacement and labels read.
+                flattenPacked(imageData.data, IsPackedValue(this.metadata));
                 // Stops win when supplied: they can express a band and a hidden floor, which a two
                 // colour ramp cannot. The pair stays the fallback so an older style still draws.
                 if (this.rampStops && this.rampStops.length > 0) {
@@ -40874,72 +41025,20 @@
                 }
                 this.applyBaselineMask(imageData.data, valuePixels, canvas.width, canvas.height);
                 if (valuePixels) {
-                    dilateValues(valuePixels, canvas.width, canvas.height, VALUE_DILATE_PASSES);
+                    dilateValues(valuePixels, canvas.width, canvas.height, VALUE_DILATE_PASSES, IsPackedValue(this.metadata));
                 }
                 return { pixels: imageData.data, width: canvas.width, height: canvas.height, valuePixels };
             }
             /*
-             * Paints one frame's pixels onto a canvas, resampled into the drape extent when there is one.
+             * Paints one frame's composited pixels onto a canvas.
              */
             writeInto(canvas, pixels, dims) {
-                const rect = this.sourceRect(dims);
-                if (!rect) {
-                    canvas.width = dims.width;
-                    canvas.height = dims.height;
-                    const direct = canvas.getContext("2d");
-                    const image = direct.createImageData(dims.width, dims.height);
-                    image.data.set(pixels);
-                    direct.putImageData(image, 0, 0);
-                    return;
-                }
-                if (!this.scratch) {
-                    this.scratch = document.createElement("canvas");
-                }
-                this.scratch.width = dims.width;
-                this.scratch.height = dims.height;
-                const scratchCtx = this.scratch.getContext("2d");
-                const image = scratchCtx.createImageData(dims.width, dims.height);
-                image.data.set(pixels);
-                scratchCtx.putImageData(image, 0, 0);
                 canvas.width = dims.width;
                 canvas.height = dims.height;
                 const ctx = canvas.getContext("2d");
-                // Nearest neighbour: a value texel has to survive the resample exactly, or a label reads
-                // a blend of two cells rather than the cell it points at.
-                ctx.imageSmoothingEnabled = false;
-                ctx.clearRect(0, 0, dims.width, dims.height);
-                ctx.drawImage(this.scratch, rect.x, rect.y, rect.width, rect.height, 0, 0, dims.width, dims.height);
-            }
-            /*
-             * The part of the archive raster that the drape extent covers, in source pixels.
-             */
-            sourceRect(dims) {
-                const drape = this.drapeExtent;
-                const m = this.metadata;
-                // A composited frame was drawn into the drape extent already, so resampling it again
-                // would apply the same correction twice.
-                if (this.tiles) {
-                    return null;
-                }
-                if (!drape || !m || m.West == null || m.East == null || m.South == null || m.North == null) {
-                    return null;
-                }
-                const spanLon = m.East - m.West;
-                const spanLat = m.North - m.South;
-                if (!(spanLon > 0) || !(spanLat > 0)) {
-                    return null;
-                }
-                const x = (drape.West - m.West) / spanLon * dims.width;
-                const width = (drape.East - drape.West) / spanLon * dims.width;
-                const y = (m.North - drape.North) / spanLat * dims.height;
-                const height = (drape.North - drape.South) / spanLat * dims.height;
-                // A drape that already matches the archive is the common case and must not pay for a
-                // resample, nor lose a half pixel to rounding.
-                if (Math.abs(x) < 0.01 && Math.abs(y) < 0.01
-                    && Math.abs(width - dims.width) < 0.01 && Math.abs(height - dims.height) < 0.01) {
-                    return null;
-                }
-                return { x, y, width, height };
+                const image = ctx.createImageData(dims.width, dims.height);
+                image.data.set(pixels);
+                ctx.putImageData(image, 0, 0);
             }
             /**
              * The archive's per-cell floor and ceiling rasters, once EnsureExtremes has resolved.
@@ -40951,45 +41050,16 @@
              * Fetches and decodes the floor and ceiling rasters, at most once.
              */
             EnsureExtremes() {
-                if (this.extremesLoad) {
-                    return this.extremesLoad;
-                }
-                if (this.tiles) {
+                if (!this.extremesLoad) {
                     this.extremesLoad = this.loadTiledExtremes();
-                    return this.extremesLoad;
-                }
-                const floor = this.metadata && this.metadata.Floor;
-                const ceiling = this.metadata && this.metadata.Ceiling;
-                if (!floor && !ceiling) {
-                    this.extremesLoad = Promise.resolve();
-                    return this.extremesLoad;
-                }
-                this.extremesLoad = Promise.all([
-                    floor ? this.loadImageDataAt(floor) : Promise.resolve(null),
-                    ceiling ? this.loadImageDataAt(ceiling) : Promise.resolve(null)
-                ]).then(([f, c]) => {
-                    if (this.disposed) {
-                        return;
-                    }
-                    this.floorPixels = f;
-                    this.ceilingPixels = c;
-                }).catch((e) => {
-                    // Missing extremes cost a label its range, and must not take the animation with them.
-                    console.warn("TextureFrameSeriesAnimator: could not load the extremes rasters.", e);
-                });
+                }
                 return this.extremesLoad;
             }
             /*
              * Composites each tile's baseline mask into one covering the composited frames.
-             *
-             * A tiled archive publishes the mask per tile, so reading the archive level BaselineMask
-             * finds nothing and hiding dry cells silently does nothing at all.
              */
             async loadTiledBaselineMask() {
                 const tiles = this.tiles;
-                if (!tiles) {
-                    return;
-                }
                 const entries = tiles.map((tile) => tile.BaselineMask);
                 let lo = Number.MAX_SAFE_INTEGER;
                 let hi = 0;
@@ -41043,14 +41113,11 @@
             /*
              * Composites each tile's floor and ceiling into rasters matching the composited frames.
              *
-             * A tiled archive has no whole-extent extremes to fetch, only per-tile ones, and a label
-             * indexes them by the same texel as the value canvas, so they have to be laid out the same way.
+             * A label indexes them by the same texel as the value canvas, so they have to be laid out the
+             * same way rather than fetched as whole-extent rasters.
              */
             async loadTiledExtremes() {
                 const tiles = this.tiles;
-                if (!tiles) {
-                    return;
-                }
                 const target = this.compositeExtent();
                 const size = this.compositeSize(tiles, target);
                 // One request for the whole extremes block. They sit contiguously after the frames, so
@@ -41145,70 +41212,6 @@
                     }
                 }));
             }
-            /*
-             * Range GETs one entry and decodes it to an image.
-             */
-            async loadImageAt(entry) {
-                const start = entry.ByteOffset;
-                const end = entry.ByteOffset + entry.ByteLength - 1;
-                const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${start}-${end}` } });
-                const buffer = await response.arrayBuffer();
-                const objectUrl = URL.createObjectURL(new Blob([buffer], { type: "image/png" }));
-                try {
-                    return await loadImage(objectUrl);
-                }
-                finally {
-                    URL.revokeObjectURL(objectUrl);
-                }
-            }
-            /*
-             * Puts a static raster through the same resample the frames get.
-             */
-            remap(image) {
-                if (!image) {
-                    return null;
-                }
-                const rect = this.sourceRect({ width: image.width, height: image.height });
-                if (!rect) {
-                    return image;
-                }
-                const from = document.createElement("canvas");
-                from.width = image.width;
-                from.height = image.height;
-                from.getContext("2d").putImageData(image, 0, 0);
-                const to = document.createElement("canvas");
-                to.width = image.width;
-                to.height = image.height;
-                const ctx = to.getContext("2d");
-                ctx.imageSmoothingEnabled = false;
-                ctx.clearRect(0, 0, image.width, image.height);
-                ctx.drawImage(from, rect.x, rect.y, rect.width, rect.height, 0, 0, image.width, image.height);
-                return ctx.getImageData(0, 0, image.width, image.height);
-            }
-            /*
-             * Range GETs one entry out of the blob and decodes it to pixels.
-             */
-            async loadImageDataAt(entry) {
-                const start = entry.ByteOffset;
-                const end = entry.ByteOffset + entry.ByteLength - 1;
-                const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${start}-${end}` } });
-                const buffer = await response.arrayBuffer();
-                const blob = new Blob([buffer], { type: "image/png" });
-                const objectUrl = URL.createObjectURL(blob);
-                let image;
-                try {
-                    image = await loadImage(objectUrl);
-                }
-                finally {
-                    URL.revokeObjectURL(objectUrl);
-                }
-                const canvas = document.createElement("canvas");
-                canvas.width = image.width;
-                canvas.height = image.height;
-                const ctx = canvas.getContext("2d");
-                ctx.drawImage(image, 0, 0);
-                return ctx.getImageData(0, 0, canvas.width, canvas.height);
-            }
             /**
              * Fetches and decodes the archive's static baseline mask, at most once.
              */
@@ -41351,7 +41354,7 @@
         function Now() {
             return typeof performance !== "undefined" ? performance.now() : Date.now();
         }
-    })(TextureFrameSeriesAnimator || (TextureFrameSeriesAnimator = {}));
+    })(exports.TextureFrameSeriesAnimator || (exports.TextureFrameSeriesAnimator = {}));
 
     (function (TextureValueLabels) {
         // Off by default: a caller can still set a floor, but thinning is the mechanism that keeps a
@@ -41399,6 +41402,49 @@
             return out;
         }
         TextureValueLabels.ClipOutline = ClipOutline;
+        /**
+         * One cell's numbers as a label should print them, or null where the texture has no data there.
+         * @param params at is the index of the cell's red channel. sourceMap is derived from the metadata
+         * when omitted, which a caller reading many cells should hoist rather than repeat.
+         */
+        function ReadingAt(params) {
+            const { metadata, source, floor, ceiling, at } = params;
+            if (source.data[at + 3] < 128) {
+                return null;
+            }
+            const lo = metadata && typeof metadata.ValueMin === "number" ? metadata.ValueMin : 0;
+            const hi = metadata && typeof metadata.ValueMax === "number" ? metadata.ValueMax : 1;
+            const normalised = exports.TextureFrameSeriesAnimator.NormalisedAt(metadata, source.data, at);
+            const toSource = params.sourceMap !== undefined
+                ? params.sourceMap
+                : exports.TextureFrameSeriesAnimator.SourceMap(metadata);
+            const inSource = (value) => exports.TextureFrameSeriesAnimator.ToSource(toSource, value);
+            const reading = { value: inSource(lo + normalised * (hi - lo)) };
+            const eLo = metadata && metadata.ExtremesValueMin;
+            const eHi = metadata && metadata.ExtremesValueMax;
+            if (typeof eLo === "number" && typeof eHi === "number") {
+                if (floor) {
+                    reading.floor = inSource(eLo + decode16(floor.data, at) * (eHi - eLo));
+                }
+                if (ceiling) {
+                    reading.ceiling = inSource(eLo + decode16(ceiling.data, at) * (eHi - eLo));
+                }
+            }
+            return reading;
+        }
+        TextureValueLabels.ReadingAt = ReadingAt;
+        /**
+         * The unit a label's value line should name, or undefined when the archive states none.
+         * @param metadata the archive's Data.generation
+         */
+        function LabelUnits(metadata) {
+            if (!metadata) {
+                return undefined;
+            }
+            const recovered = exports.TextureFrameSeriesAnimator.SourceMap(metadata);
+            return (recovered && metadata.SourceUnits) || metadata.Units;
+        }
+        TextureValueLabels.LabelUnits = LabelUnits;
         /**
          * How many cells apart labels should sit, as a power of two.
          * @param options cellPixels is one cell's size on screen, held is the stride already in use
@@ -41425,6 +41471,7 @@
         TextureValueLabels.ChooseLabelStride = ChooseLabelStride;
         class Labels {
             constructor(options) {
+                this.sourceMap = null;
                 this.source = null;
                 this.painted = null;
                 this.floor = null;
@@ -41436,6 +41483,9 @@
                 this.extent = options.extent;
                 this.settings = options.settings || {};
                 this.metadata = options.metadata;
+                // Once per overlay rather than once per cell: a label pass probes thousands of texels
+                // looking for one worth labelling, and the map cannot change while the metadata does not.
+                this.sourceMap = exports.TextureFrameSeriesAnimator.SourceMap(options.metadata);
                 this.tiles = options.tiles;
                 this.clipRing = options.clipRing;
                 this.canvas = document.createElement("canvas");
@@ -41851,7 +41901,7 @@
             widestLabel(parts) {
                 const sample = [];
                 if (parts.indexOf("value") >= 0) {
-                    sample.push("-000.00");
+                    sample.push(valueLine("-000.00", LabelUnits(this.metadata)));
                 }
                 const range = [];
                 if (parts.indexOf("floor") >= 0) {
@@ -41891,7 +41941,7 @@
                 const dp = (_a = this.settings.decimals) !== null && _a !== void 0 ? _a : (Math.abs(reading.value) < 10 ? 2 : 1);
                 const lines = [];
                 if (parts.indexOf("value") >= 0) {
-                    lines.push(reading.value.toFixed(dp));
+                    lines.push(valueLine(reading.value.toFixed(dp), LabelUnits(this.metadata)));
                 }
                 // Named rather than a bare pair: two numbers under a third say nothing about which is
                 // the series low and which is its high.
@@ -41965,29 +42015,17 @@
             }
             // Decodes one cell, skipping anything the texture marks as having no data.
             readAt(col, row, cols) {
-                var _a, _b;
-                const i = (row * cols + col) * 4;
-                if (!this.source || this.source.data[i + 3] < 128) {
+                if (!this.source) {
                     return null;
                 }
-                const lo = this.metadata && typeof this.metadata.ValueMin === "number" ? this.metadata.ValueMin : 0;
-                const hi = this.metadata && typeof this.metadata.ValueMax === "number" ? this.metadata.ValueMax : 1;
-                const value = lo + (this.source.data[i] / 255) * (hi - lo);
-                const reading = { value };
-                const eLo = (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.ExtremesValueMin;
-                const eHi = (_b = this.metadata) === null || _b === void 0 ? void 0 : _b.ExtremesValueMax;
-                if (this.floor && typeof eLo === "number" && typeof eHi === "number") {
-                    reading.floor = eLo + decode16(this.floor.data, i) * (eHi - eLo);
-                    // An anomaly archive's frames are already floor-relative, so the reading a user
-                    // wants is the absolute one. This is the whole reason the floor is published.
-                    if (TextureFrameSeriesAnimator.IsAnomalyMeasure(this.metadata)) {
-                        reading.value += reading.floor;
-                    }
-                }
-                if (this.ceiling && typeof eLo === "number" && typeof eHi === "number") {
-                    reading.ceiling = eLo + decode16(this.ceiling.data, i) * (eHi - eLo);
-                }
-                return reading;
+                return ReadingAt({
+                    metadata: this.metadata,
+                    source: this.source,
+                    floor: this.floor,
+                    ceiling: this.ceiling,
+                    at: (row * cols + col) * 4,
+                    sourceMap: this.sourceMap
+                });
             }
             lonAt(col, cols) {
                 return this.extent.West + ((col + 0.5) / cols) * (this.extent.East - this.extent.West);
@@ -42026,6 +42064,13 @@
             }
         }
         TextureValueLabels.Labels = Labels;
+        /*
+         * The value line. Units go on it alone: repeating them on the range underneath doubles the widest
+         * label to say nothing, and the two lines are plainly the same quantity.
+         */
+        function valueLine(value, units) {
+            return units ? `${value} (${units})` : value;
+        }
         function decode16(data, i) {
             return (data[i] * 256 + data[i + 1]) / 65535;
         }
@@ -42046,11 +42091,6 @@
         const SKIRT_FRACTION = 0.015;
         // Alpha below which a texel counts as no-data and is not drawn at all.
         const COVERAGE_CUTOFF = 0.35;
-        // With no exaggeration stated, the full value range is drawn as this fraction of the extent's shorter side.
-        const AUTO_RELIEF_FRACTION = 0.02;
-        // Ceiling on the derived relief. Sizing purely off the extent is fine for a parcel and absurd for
-        // a whole estuary: 4 m of water over an 82 km extent came out 1.6 km tall.
-        const AUTO_MAX_RELIEF_METRES = 250.0;
         // Terrain is sampled on this grid and interpolated between samples.
         // Per-texel sampling would be hundreds of thousands of lookups for a surface whose own data is far coarser than that.
         const GROUND_SAMPLES_PER_SIDE = 64;
@@ -42071,6 +42111,7 @@ in float skirt;
 
 uniform sampler2D u_valueTexture;
 uniform sampler2D u_groundTexture;
+uniform float u_valuePacked;
 uniform float u_valueMin;
 uniform float u_valueRange;
 uniform float u_exaggeration;
@@ -42108,18 +42149,37 @@ float sampleGround(vec2 uv) {
     return mix(mix(h00, h10, f.x), mix(h01, h11, f.x), f.y);
 }
 
+/*
+ * The texel's normalised value, whichever way the archive packed it.
+ *
+ * A packed frame keeps the high byte in R, so reading R alone would quantise the whole range to 255
+ * steps and draw a plausible wrong surface rather than an obviously broken one.
+ *
+ * Each channel is scaled and then added, rather than reassembled to a 0..65535 integer and divided.
+ * That integer is outside the range mediump guarantees, and a fragment shader only gets highp where
+ * the device offers it, so the obvious form loses the low byte on exactly the older mobile hardware
+ * that Cesium falls back to mediump for.
+ */
+float decodeValue(vec4 texel) {
+    float packed16 = texel.r * (255.0 * 256.0 / 65535.0) + texel.g * (255.0 / 65535.0);
+    return mix(texel.r, packed16, u_valuePacked);
+}
+
 void main() {
     vec4 texel = texture(u_valueTexture, st);
     v_st = st;
-    v_value = texel.r;
+    v_value = decodeValue(texel);
     v_coverage = texel.a;
 
-    float metres = u_valueMin + texel.r * u_valueRange;
+    // Exaggeration stretches the span above the archive's minimum rather than the height itself. On an
+    // elevation the height is measured from the ellipsoid, tens of metres from any of the data, so
+    // scaling that instead translates the whole sheet underground rather than spreading it out.
+    float metres = u_valueMin + v_value * u_valueRange * u_exaggeration;
 
     // Value zero sits at the polygon's own altitude, plus the terrain underneath when the polygon
     // is following the ground rather than absolutely positioned.
     float ground = sampleGround(st) * u_groundWeight;
-    float displacement = u_baseHeight + ground + metres * u_exaggeration * texel.a - skirt * u_skirtDepth;
+    float displacement = u_baseHeight + ground + metres * texel.a - skirt * u_skirtDepth;
 
     // Added to the LOW half of the encoded position: a metre-scale offset added to the high half
     // would be lost to float32 rounding at an earth radius.
@@ -42132,6 +42192,7 @@ uniform sampler2D u_valueTexture;
 uniform sampler2D u_rampTexture;
 uniform float u_coverageCutoff;
 uniform vec2 u_texelSize;
+uniform float u_valuePacked;
 uniform float u_valueRange;
 uniform float u_exaggeration;
 uniform float u_metresPerTexel;
@@ -42140,6 +42201,16 @@ in vec2 v_st;
 in float v_value;
 in float v_coverage;
 
+/*
+ * Scaled per channel for the same reason the vertex shader's decode is: reassembling the pair reaches
+ * 65535, which mediump does not have to represent, and this is the shader that may not get highp.
+ */
+float valueAt(vec2 uv) {
+    vec4 texel = texture(u_valueTexture, uv);
+    float packed16 = texel.r * (255.0 * 256.0 / 65535.0) + texel.g * (255.0 / 65535.0);
+    return mix(texel.r, packed16, u_valuePacked);
+}
+
 void main() {
     if (v_coverage < u_coverageCutoff) {
         discard;
@@ -42154,10 +42225,10 @@ void main() {
 
     // Relief shading from the value gradient, so the displacement reads at a distance without
     // recomputing vertex normals every time the texture changes.
-    float left = texture(u_valueTexture, v_st - vec2(u_texelSize.x, 0.0)).r;
-    float right = texture(u_valueTexture, v_st + vec2(u_texelSize.x, 0.0)).r;
-    float down = texture(u_valueTexture, v_st - vec2(0.0, u_texelSize.y)).r;
-    float up = texture(u_valueTexture, v_st + vec2(0.0, u_texelSize.y)).r;
+    float left = valueAt(v_st - vec2(u_texelSize.x, 0.0));
+    float right = valueAt(v_st + vec2(u_texelSize.x, 0.0));
+    float down = valueAt(v_st - vec2(0.0, u_texelSize.y));
+    float up = valueAt(v_st + vec2(0.0, u_texelSize.y));
     float scale = u_valueRange * u_exaggeration;
     vec3 n = normalize(vec3((left - right) * scale, (down - up) * scale, 2.0 * u_metresPerTexel));
     float lambert = clamp(dot(n, normalize(vec3(-0.5, -0.6, 0.62))), 0.0, 1.0);
@@ -42367,8 +42438,9 @@ void main() {
                 this.source = options.source || null;
                 this.valueMin = (_a = options.valueMin) !== null && _a !== void 0 ? _a : 0;
                 this.valueMax = (_b = options.valueMax) !== null && _b !== void 0 ? _b : 1;
-                this.exaggeration = (_c = options.exaggeration) !== null && _c !== void 0 ? _c : autoExaggeration(this.extent, this.valueMin, this.valueMax);
+                this.exaggeration = (_c = options.exaggeration) !== null && _c !== void 0 ? _c : 1;
                 this.baseHeight = (_d = options.baseHeight) !== null && _d !== void 0 ? _d : 0;
+                this.packedValue = Boolean(options.packedValue);
                 this.pixelPlacement = options.pixelPlacement;
                 this.tileSkirts = Boolean(options.tileSkirts);
                 this.rampPixels = RampLookup(options.rampStops || null, options.lowColor || DEFAULT_LOW_COLOR, options.highColor || DEFAULT_HIGH_COLOR);
@@ -42592,6 +42664,14 @@ void main() {
                     if (this.texture) {
                         this.texture.destroy();
                     }
+                    // Nearest for a packed value, because filtering would blend the two bytes of the
+                    // packing rather than the values they encode, the same trap sampleGround avoids.
+                    const minification = this.packedValue
+                        ? Cesium.TextureMinificationFilter.NEAREST
+                        : Cesium.TextureMinificationFilter.LINEAR;
+                    const magnification = this.packedValue
+                        ? Cesium.TextureMagnificationFilter.NEAREST
+                        : Cesium.TextureMagnificationFilter.LINEAR;
                     this.texture = new Cesium.Texture({
                         context,
                         source: this.source,
@@ -42601,8 +42681,8 @@ void main() {
                         sampler: new Cesium.Sampler({
                             wrapS: Cesium.TextureWrap.CLAMP_TO_EDGE,
                             wrapT: Cesium.TextureWrap.CLAMP_TO_EDGE,
-                            minificationFilter: Cesium.TextureMinificationFilter.LINEAR,
-                            magnificationFilter: Cesium.TextureMagnificationFilter.LINEAR
+                            minificationFilter: minification,
+                            magnificationFilter: magnification
                         })
                     });
                     this.textureDirty = false;
@@ -42703,6 +42783,7 @@ void main() {
                         uniformMap: {
                             u_valueTexture: () => self.texture,
                             u_groundTexture: () => self.groundTexture,
+                            u_valuePacked: () => (self.packedValue ? 1 : 0),
                             u_groundWeight: () => (self.followGround && self.groundPixels ? 1 : 0),
                             u_groundRange: () => new Cesium.Cartesian2(GROUND_MIN_METRES, GROUND_MAX_METRES),
                             u_groundSize: () => new Cesium.Cartesian2(self.groundPixels ? GROUND_SAMPLES_PER_SIDE : 1, self.groundPixels ? GROUND_SAMPLES_PER_SIDE : 1),
@@ -42755,31 +42836,6 @@ void main() {
             }
             return tiles;
         }
-        /**
-         * Exaggeration that makes the full value range stand AUTO_RELIEF_FRACTION of the extent tall.
-         *
-         * Derived from the whole extent rather than per tile: scaling each tile to its own size would
-         * make neighbours disagree along their shared edge and tear the surface apart.
-         * @param extent
-         * @param valueMin
-         * @param valueMax
-         */
-        function autoExaggeration(extent, valueMin, valueMax) {
-            const range = Math.abs(valueMax - valueMin);
-            if (!(range > 0)) {
-                return 1;
-            }
-            const southWest = Cesium.Cartesian3.fromDegrees(extent.West, extent.South, 0);
-            const southEast = Cesium.Cartesian3.fromDegrees(extent.East, extent.South, 0);
-            const northWest = Cesium.Cartesian3.fromDegrees(extent.West, extent.North, 0);
-            const shorterSide = Math.min(Cesium.Cartesian3.distance(southWest, southEast), Cesium.Cartesian3.distance(southWest, northWest));
-            if (!(shorterSide > 0)) {
-                return 1;
-            }
-            const relief = Math.min(shorterSide * AUTO_RELIEF_FRACTION, AUTO_MAX_RELIEF_METRES);
-            return relief / range;
-        }
-        DisplacedSurfacePrimitive.autoExaggeration = autoExaggeration;
         function now() {
             return typeof performance !== "undefined" ? performance.now() : Date.now();
         }
@@ -43517,12 +43573,12 @@ void main() {
             && existingAnimator.GetArchiveUrl() === extrusionArchive.url
             && existingSurface
             && !existingSurface.isDestroyed();
-        const placement = surfacePlacement(entity, heightRef);
+        const placement = surfacePlacement(entity, heightRef, extrusionArchive && exports.TextureFrameSeriesAnimator.IsDatumHeight(extrusionArchive.metadata));
         // Whether the surface follows terrain is baked into its ground sampling, so a change there has
         // to rebuild rather than update in place.
         if (reusable && existingSurface.GetFollowsGround() === placement.followGround) {
             existingSurface.SetBaseHeight(placement.baseHeight);
-            existingSurface.SetExaggeration(exaggerationFor(style, extrusionArchive.metadata, existingSurface.GetExtent()));
+            existingSurface.SetExaggeration(exaggerationFor(style));
             return;
         }
         disposeDisplacedSurface(cEntity, viewer);
@@ -43536,7 +43592,7 @@ void main() {
         }
         // Drives the value canvas only: the surface paints the colour, so the polygon's own material is
         // left transparent rather than animated underneath it.
-        const animator = new TextureFrameSeriesAnimator.Animator({
+        const animator = new exports.TextureFrameSeriesAnimator.Animator({
             viewer,
             entity: cEntity,
             archiveUrl: extrusionArchive.url,
@@ -43546,8 +43602,6 @@ void main() {
             produceValueCanvas: true,
             metadata: extrusionArchive.metadata,
             cellTexels: 1,
-            baselineMask: extrusionArchive.metadata.BaselineMask,
-            // Off-type for the same reason as the fill path: the pinned bruce-models predates the field.
             maskBaseline: style.maskTextureBaseline
         });
         cEntity[EXTRUSION_ANIMATOR_KEY] = animator;
@@ -43562,13 +43616,14 @@ void main() {
             terrainProvider: viewer && viewer.terrainProvider,
             valueMin: extrusionArchive.metadata.ValueMin,
             valueMax: extrusionArchive.metadata.ValueMax,
-            exaggeration: exaggerationFor(style, extrusionArchive.metadata, extent),
+            packedValue: exports.TextureFrameSeriesAnimator.IsPackedValue(extrusionArchive.metadata),
+            exaggeration: exaggerationFor(style),
             lowColor: mask ? BModels.Color.ColorFromStr(mask.minColor) : null,
             highColor: mask ? BModels.Color.ColorFromStr(mask.maxColor) : null,
             // Normalised the same way the animator normalises them, so the surface and the flat drape
             // agree about which values the style hides.
-            rampStops: (mask && mask.points || []).map((stop) => ({
-                position: TextureFrameSeriesAnimator.NormalisePosition(extrusionArchive.metadata, stop.position),
+            rampStops: ((mask && mask.points) || []).map((stop) => ({
+                position: exports.TextureFrameSeriesAnimator.NormalisePosition(extrusionArchive.metadata, stop.position),
                 color: BModels.Color.ColorFromStr(stop.color)
             })).filter((stop) => Boolean(stop.color))
         });
@@ -43583,7 +43638,7 @@ void main() {
      * @param entity
      * @param heightRef
      */
-    function surfacePlacement(entity, heightRef) {
+    function surfacePlacement(entity, heightRef, datumHeight) {
         const rawAltitude = BModels.Entity.GetValue({
             entity,
             path: ["Bruce", "Location", "altitude"]
@@ -43595,32 +43650,18 @@ void main() {
         if (heightRef === Cesium.HeightReference.RELATIVE_TO_GROUND) {
             return { baseHeight: altitude, followGround: true };
         }
-        return { baseHeight: altitude, followGround: false };
+        // Values that ARE heights against a datum already say where they belong, so adding the entity's
+        // altitude on top would move a measured surface off the datum it was measured against.
+        return { baseHeight: datumHeight ? 0 : altitude, followGround: false };
     }
-    /**
-     * The archive's own extent when it recorded one, otherwise the polygon's own bounds so archives
-     * generated before the extent was written still render somewhere sensible.
-     * @param metadata
-     * @param posses
-     */
     /*
-     * The factor a displaced surface should use, honouring an explicit style setting first.
-     *
-     * An elevation is a real height against a datum, so scaling it is not a display choice: it lifts the
-     * surface off the datum it belongs to. Only a thickness is safe to exaggerate, which is why an
-     * elevation archive defaults to 1 rather than to a derived factor.
+     * The factor a displaced surface should use, which is the style's or nothing.
      */
-    function exaggerationFor(style, metadata, extent) {
+    function exaggerationFor(style) {
         if (style.extrusionExaggeration != null) {
             return style.extrusionExaggeration;
         }
-        if (metadata.Quantity === TextureFrameSeriesAnimator.QUANTITY_ELEVATION) {
-            return 1;
-        }
-        if (!extent) {
-            return undefined;
-        }
-        return exports.DisplacedSurfacePrimitive.autoExaggeration(extent, metadata.ValueMin, metadata.ValueMax);
+        return 1;
     }
     /*
      * The lon/lat bounding rectangle of a ring, which is the frame Cesium drapes an image material in.
@@ -43696,7 +43737,7 @@ void main() {
         // Appearance is part of the reuse test, not just the archive URL. Recolouring a texture-driven
         // polygon keeps the same archive, so matching on the URL alone kept the old Animator and the
         // style edit appeared to do nothing at all.
-        const appearance = TextureFrameSeriesAnimator.AppearanceSignature({
+        const appearance = exports.TextureFrameSeriesAnimator.AppearanceSignature({
             textureColorMask, cellBorder, cellTexels, maskBaseline: maskTextureBaseline,
             valueCanvas: produceValueCanvas, drape: drapeExtent
         });
@@ -43712,7 +43753,7 @@ void main() {
         if (!frameArchive) {
             return null;
         }
-        const animator = new TextureFrameSeriesAnimator.Animator({
+        const animator = new exports.TextureFrameSeriesAnimator.Animator({
             viewer,
             entity: cEntity,
             archiveUrl: frameArchive.url,
@@ -43721,7 +43762,6 @@ void main() {
             metadata: frameArchive.metadata,
             cellBorder,
             cellTexels,
-            baselineMask: frameArchive.metadata.BaselineMask,
             maskBaseline: maskTextureBaseline,
             produceValueCanvas,
             drapeExtent
@@ -43782,12 +43822,10 @@ void main() {
         }
         const labels = new exports.TextureValueLabels.Labels({
             viewer, extent, settings, metadata,
-            tiles: TextureFrameSeriesAnimator.IsTiledLayout(metadata)
-                ? metadata.Tiles.map((tile) => ({
-                    West: tile.West, East: tile.East, South: tile.South, North: tile.North,
-                    ResolutionX: tile.ResolutionX, ResolutionY: tile.ResolutionY
-                }))
-                : undefined,
+            tiles: exports.TextureFrameSeriesAnimator.TilesOf(metadata).map((tile) => ({
+                West: tile.West, East: tile.East, South: tile.South, North: tile.North,
+                ResolutionX: tile.ResolutionX, ResolutionY: tile.ResolutionY
+            })),
             clipRing: params.clipRing
         });
         let lastVersion = -1;
@@ -43920,11 +43958,15 @@ void main() {
                 const { clientFile } = await BModels.ClientFile.Get({ api, fileId: clientFileId });
                 url = clientFile.URL;
                 const clientFileData = clientFile.Data;
-                if (TextureFrameSeriesAnimator.IsFrameArchiveMetadata(clientFileData)) {
+                if (exports.TextureFrameSeriesAnimator.IsFrameArchiveMetadata(clientFileData)) {
+                    const adapted = exports.TextureFrameSeriesAnimator.Adapt(clientFileData.generation);
+                    if (!adapted) {
+                        return { dataUri: null, effective: textureTrace.effective };
+                    }
                     return {
                         dataUri: null,
                         effective: textureTrace.effective,
-                        frameArchive: { url, metadata: clientFileData.generation }
+                        frameArchive: { url, metadata: adapted }
                     };
                 }
             }
@@ -43952,8 +43994,12 @@ void main() {
         }
         const url = clientFile.URL;
         const clientFileData = clientFile.Data;
-        if (TextureFrameSeriesAnimator.IsFrameArchiveMetadata(clientFileData)) {
-            return { dataUri: null, effective: null, frameArchive: { url, metadata: clientFileData.generation } };
+        if (exports.TextureFrameSeriesAnimator.IsFrameArchiveMetadata(clientFileData)) {
+            const adapted = exports.TextureFrameSeriesAnimator.Adapt(clientFileData.generation);
+            if (adapted) {
+                return { dataUri: null, effective: null, frameArchive: { url, metadata: adapted } };
+            }
+            return { dataUri: null, effective: null };
         }
         const cacheKey = "texture-" + url + "-none";
         let prom = _textureCache.Get(cacheKey);
@@ -45422,7 +45468,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.2.2";
+    const VERSION = "7.2.3";
     /**
      * Updates the environment instance used by bruce-cesium to one specified.
      * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.