Go Colour Debugging: Converted Wide-Gamut Source Images That Look Washed Out
The page fires because converted images look washed out, yet the campaign renderer reports success. To debug the colour shift, preserve the wide-gamut source file and the delivered blog cover, then trace profile handling across decode, transform, encode, and delivery. The short promo video may look right while its cover looks pale because those artifacts can take different paths. TL;DR: treat color metadata as part of the media payload, not optional decoration. Identify the source profile, convert decoded pixels through a color-managed path into the output space, embed or explicitly signal that output space, and inspect the delivered file in more than one conforming viewer. A blind decode-resize-encode path can produce a valid image whose numbers are interpreted in the wrong color space. The first action on call is therefore not another retry. Preserve one source and one delivered artifact, record their profile signals, and compare the stages between them. Retries only reproduce a deterministic color-management mistake and consume bandwidth that should be reserved for useful renders. Why do converted wide-gamut images look washed out after colour handling? An operational status such as completed proves that the pipeline produced an artifact according to its execution contract. It does not prove visual equivalence. For an e-commerce workflow that generates a short promo video from a prompt and also publishes a still blog cover, that distinction matters: motion frames, cover thumbnails, and browser previews may pass through different decoders and encoders even when they share a source asset. Wide-gamut source files make the gap easier to see. Pixel component values have meaning only with a color-space definition. If a decoder reads values associated with one profile and a later stage labels them as another space without transforming the values, the output is misinterpreted. If an encoder drops the profile and a consumer assumes a default, the result can also differ from the managed preview upstream. The file may remain structurally valid in both cases. Start with three questions. What color space does the source declare? At which stage are pixels converted? What does the final artifact declare? Do not infer the first answer from a filename or extension. MDN’s format guide shows that JPEG, PNG, WebP, and AVIF are containers with different feature support; an extension alone is not a color-management trace. The most useful evidence is the pair that brackets the suspected boundary, so keep the original upload and the exact object served to the browser. Screenshots are weak evidence because they add the display, operating system, browser, and capture path to the chain. If the source and delivered bytes are available, an engineer can examine declared color information on both sides, identify the first boundary where it changes, and avoid arguing over two screenshots captured under different conditions. This is the practical correction to a common first move: looking at encoder quality settings before proving that the same artifact and color space are under comparison. Identity first. Work backward from the page The visible defect is the last signal, so walk upstream from it. First fetch the delivered cover through the same URL and content-negotiation path used by a reader. Verify its media type and byte identity against the stored derivative. Then inspect the derivative’s embedded or signaled color information. Repeat for the intermediate frame and source asset. This is a trace, not a gallery review: Boundary Evidence to retain Failure it can expose Ingest source digest, format, dimensions, declared profile metadata lost before processing Decode decoder name/version, detected source space source interpreted with an unintended assumption Transform input and output spaces, transform applied relabeling instead of conversion Encode output format, embedded/signaled space, artifact digest output metadata omitted or inconsistent Delivery media type, content negotiation, delivered digest a different derivative served than the one inspected Compare bytes before comparing impressions. A digest mismatch at delivery sends the investigation toward caches, variants, or object selection. A digest match with different appearance sends it toward color interpretation and the viewing environment. That branch prevents a costly mistake: tuning encoder quality when the wrong derivative is being served, or purging caches when the same file is merely being interpreted differently. Do not retry it. Keep quality and bandwidth as separate decisions. Chroma subsampling, quantization, dimensions, and codec choice affect visual fidelity and transfer size. Color conversion and profile signaling affect how component values are interpreted. They meet at the encoder, but one control should not stand in for the other. A smaller file that changes the campaign’s intended color has failed the acceptance check, however attractive its byte count looks. Add the signal that should have fired earlier The earlier alert should be about a broken media invariant, not subjective saturation. Instrument the boundary where the pipeline converts the source into the canonical working space, and again where it encodes each delivery artifact. Record bounded labels; do not put object keys, prompts, or digests into metric labels because their cardinality grows with every job. Logs can carry per-artifact detail. Metrics should aggregate outcomes such as profile_missing, transform_skipped, output_signal_missing, or ok. A trace span can link those outcomes to the render job without turning the monitoring system into an asset index. This Go shape keeps the operational contract explicit while leaving the decoder and encoder implementations replaceable: package media import ( “context” “fmt” ) type ColorSpace string const ( SpaceUnknown ColorSpace = “unknown” SpaceSRGB ColorSpace = “srgb” SpaceP3 ColorSpace = “display-p3” ) type Frame struct { Pixels []byte Space ColorSpace } type Transformer interface { Convert(context.Context, Frame, ColorSpace) (Frame, error) } type Encoder interface { Encode(context.Context, Frame) ([]byte, error) } func BuildCover(ctx context.Context, src Frame, x Transformer, enc Encoder) ([]byte, error) { if src.Space == SpaceUnknown { return nil, fmt.Errorf(“source color space is unknown”) } converted, err := x.Convert(ctx, src, SpaceSRGB) if err != nil { return nil, fmt.Errorf(“convert %s to %s: %w”, src.Space, SpaceSRGB, err) } if converted.Space != SpaceSRGB { return nil, fmt.Errorf(“transform returned %s, want %s”, converted.Space, SpaceSRGB) } artifact, err := enc.Encode(ctx, converted) if err != nil { return nil, fmt.Errorf(“encode cover: %w”, err) } return artifact, nil } The interface does not pretend that changing the Space field converts pixels. The transformer owns that operation. The encoder’s contract must separately require output signaling appropriate to its format, and an artifact inspector should verify the resulting bytes after encode. That last check catches a configuration that looks correct in memory but is not represented in the file. Fail closed when the source space is unknown for color-critical campaign assets. For a noncritical thumbnail tier, a team may choose a documented fallback, but it should be counted and visible. Silent guessing turns a data-quality problem into an intermittent visual one. The trade-off is explicit: rejecting one ambiguous input costs throughput now, while accepting it without a recorded policy can publish a plausible but incorrect campaign artifact that is harder to diagnose later. Test the artifact, not the happy-path function A unit test around the resize function is too narrow. Build a small corpus that crosses the boundaries the production pipeline actually accepts: a source with an embedded ICC profile, a source using format-specific color signaling, a source with no usable declaration, and a known output in the chosen delivery space. The reference images must come from a controlled fixture set with documented provenance; random web images are poor golden files. Run each fixture through the same decode, transform, resize, and encode path used in production. Then parse the output and assert that the expected profile or color-space signal is present. For pixel comparison, decode both expected and actual artifacts into the same comparison space before calculating a difference. Comparing raw encoded component values across color spaces answers the wrong question. Visual review still has a place. Use it as a release check on representative devices and browsers, after machine-verifiable invariants have passed. The CSS Color Module Level 4 specification documents how CSS colors and profiles relate to color spaces on the web, while the image format specifications define the metadata available inside each asset. Neither removes the need to test the complete delivery path. One viewer isn’t a test matrix. One short test catches a surprising number of regressions: process the fixture, retrieve the published derivative through the public delivery path, and require its digest to equal the artifact approved by the pipeline. Then inspect its color signal. Two assertions, two different failure domains. Deployment should be canaried by artifact class rather than by request count alone. Promo-video frames and blog covers may use different encode paths, so success for one does not clear the other. During a codec or library change, compare the new and old paths in the same declared comparison space, retain the input profile classification, and watch the unknown-profile rate. Version the processing policy with the artifact metadata so a later investigation can reconstruct which rules were active. Tune alerts without paging on taste Page when a deterministic contract is broken and immediate action can protect current campaign output: the transform was skipped, the output’s required color signal is absent, or delivery returns bytes other than the approved artifact. Route trends such as a rising share of unknown source profiles to a ticket or dashboard until they cross a separately justified operational threshold. Avoid alerts based on a generic color-difference score with no content context. A deliberate creative edit can move that score, and a small numeric difference can still be conspicuous in a flat brand color. Thresholds need fixture-based calibration and a defined response. Otherwise the alert fires on valid creative variation, teaches on-call staff to ignore it, and competes with missed jobs or duplicate deliveries for attention. There is a real bandwidth trade-off. Embedding metadata adds bytes, and choosing a broadly interoperable delivery space can represent fewer colors than a wider-gamut source. The decision rule is straightforward: define the delivery contract per artifact class, transform rather than relabel, verify the encoded result, and measure size only among outputs that already meet the visual contract. Correct interpretation is the admission test; compression is the optimization. The false-positive cost closes the loop. A page that cannot distinguish intentional grading from a lost transform spends human attention without protecting users. Instrument objective boundaries first. Keep perceptual drift in release evaluation until the team has a corpus, a comparison space, and evidence for an actionable threshold. Further reading https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Image_types https://www.w3.org/TR/css-color-4/ https://www.color.org/specification/ICC.1-2022-05.pdf https://www.w3.org/TR/png-3/ https://www.w3.org/Graphics/JPEG/itu-t81.pdf