Your First April Content Update Addressables Warm Catalog Receipt After March Capstone - One Evening - 2026

April 2027 release teams will set april_content_update_allowed: true after a clean March closeout, publish a Unity Addressables remote catalog, and still leave the first real player to discover a cold CDN object or an old catalog edge response. That sequence becomes especially expensive after Summer Sale traffic spikes: a remote catalog can appear uploaded, while the content hash it names has not been requested from the actual public route, the cache rule is wrong, or the installed player never resolves the intended remote label.

This is being planned in mid-July 2026 because the useful time to design the April 2027 operational path is before the capstone calendar is busy. A March approval latch is necessary, but it is not proof that a remote catalog works. The next action is a short, separately owned warm-path receipt: prove the capstone permits the update, pin the built catalog and content hashes, request the catalog through the public CDN path, and make an installed player load a deliberately chosen remote label.

Direct answer: after the March capstone passes, spend one evening creating april_content_update_warm_catalog_receipt_v1.json. Run gates A1–A6. Require april_content_update_allowed: true, record the catalog and content hashes from the exact ServerData output, smoke the public CDN catalog path, run an installed player against a remote label, and write warm_catalog_ok: true to the project’s BUILD_RECEIPT only after all evidence points to the same build.

This is not a replacement for your normal release checks. It is the thin, reproducible bridge between “April updates are authorized” and “the first player can retrieve this exact remote catalog.”

Why this matters now

Addressables makes content updates practical because a player can retrieve catalogs and bundles separately from a full executable release. That flexibility also creates a boundary where teams can accidentally prove the wrong thing.

A successful build can prove that Unity generated catalog files. A successful upload can prove that files reached a storage origin. A successful CI job can prove that a branch produced artifacts. None of those alone proves that the public endpoint returns the intended catalog, that its bundle references are reachable, or that a player on a clean device resolves a remote label using the update you just published.

For April 2027 planning, the timing matters for five reasons:

1. March capstone approval is a decision, not a transport test. The previous Friday’s closeout should determine whether April work is allowed. It should not silently claim that CDN or player delivery is healthy.
2. Remote catalogs are cache-sensitive. A stale edge object, an incorrect cache-control rule, a path typo, or an origin permission issue may be invisible when testing from a warm developer browser.
3. Content hashes give you a stable identity. File names and build timestamps are weak evidence. A catalog hash and the hash of one required bundle let a reviewer compare the build output, CDN response, and receipt without guessing.
4. Summer Sale traffic changes failure cost. When an update is first hit under a higher player load, a cold route, redirect issue, or unavailable object becomes a player-facing incident instead of a one-minute release check.
5. One evening is enough when scope stays narrow. This is not production patch-week drift validation. It is a single known-good catalog, one documented remote label, one public CDN request path, and one installed-player proof.

Unity’s current Addressables documentation explains how remote content, catalogs, profile variables, and content updates fit together. Read the relevant version for your project before changing build or hosting configuration: Unity Addressables documentation and Unity’s Addressables remote content guidance are the authoritative references.

Who this one-evening ritual is for

Time: 90 minutes for the first pass; 25–40 minutes after the script and player diagnostic are established.

Prerequisites:

• A Unity project using Addressables.
• A remote build and load path configured through the Addressables profile used for the candidate update.
• One remote Addressables label that is safe to load in a test build, such as april-warm-smoke.
• Access to the generated ServerData directory or your equivalent content-build output.
• A public or staging CDN endpoint that the target player can reach.
• The passed March capstone receipt or BUILD_RECEIPT pointer containing april_content_update_allowed: true.
• An installed development or release-candidate build. Editor-only proof is not enough.

If you do not yet have a structured release record, start with Your First BUILD_RECEIPT JSON and Upload Log - One Evening. It establishes the smaller evidence habit this article extends.

Format ladder - where this article fits

One topic should not become several URLs that all repeat the same checklist. The release-content format ladder gives each piece a separate job.

Non-repetition note: Friday March capstone closeout owns the april_content_update_allowed latch through C1–C10. It does not prove a warm catalog path. The catalog drift validation loop owns patch-week production drift. Build content hash lockfiles owns catalog-hash survival through CI branch churn. The Invalid Key challenge owns an audit challenge. This URL owns the one-evening warm catalog receipt after capstone approval.

Gates A1–A6

Do not mark the receipt green because “most of it worked.” Each gate answers a distinct release question.

A gate may be PASS, FAIL, or NOT_RUN. Do not use “partial pass.” If an exception is genuinely required, record it as a failed gate with an owner, expiry time, and promotion decision. That keeps a waiver visible rather than turning it into an accidental green signal.

Evening overview - four short blocks

Block 1 - choose the exact candidate

Start with one build identifier. It can be a CI run URL, commit SHA, release candidate ID, or content-build timestamp, but it must be specific enough to locate the exact ServerData directory again.

Create a working folder such as:

release-evidence/
  april-2027/
    warm-catalog/
      2027-04-02-rc01/
        april_content_update_warm_catalog_receipt_v1.json
        catalog.response.json
        catalog.body.json
        player-warm-smoke.log

Then open the March capstone evidence. Do not copy the permission latch by hand. Record its file path and the value you read.

{
  "capstone_receipt": "release-evidence/march-2027/march_capstone_closeout_receipt_v1.json",
  "capstone_build_receipt": "release-evidence/BUILD_RECEIPT.json",
  "april_content_update_allowed": true
}

This is A1. The crosswalk matters because the April warm receipt consumes a decision made elsewhere. If A1 is false, no amount of working CDN output authorizes the update.

Block 2 - pin what Unity built

In the Addressables Groups window, confirm that the smoke label belongs to an entry in a group configured for the intended remote delivery path. Then run the same Addressables content build used for the candidate. Do not build locally with a different profile and call it proof for CI output.

A common layout looks like this:

ServerData/
  Windows/
    catalog.json
    catalog.hash
    remote_assets_8f12c.bundle
    remote_assets_8f12c.bundle.hash

Your names and platform folder will differ. The evidence principle does not: record the exact paths and calculate hashes from those files.

PowerShell example:

$catalog = "ServerData\Windows\catalog.json"
$catalogHashFile = "ServerData\Windows\catalog.hash"
$bundle = "ServerData\Windows\remote_assets_8f12c.bundle"

Get-FileHash $catalog -Algorithm SHA256
Get-Content $catalogHashFile
Get-FileHash $bundle -Algorithm SHA256

The Addressables-generated .hash file is useful to its own catalog update mechanism, but it is not automatically the same as a SHA-256 checksum. Keep their meanings distinct:

• catalog.hash: the Addressables catalog hash file, if your build generates one.
• catalog_sha256: a SHA-256 checksum you calculate and use in your receipt.
• content_sha256: the SHA-256 checksum of at least one required remote bundle used by the smoke label.

A2 passes when the receipt’s catalog checksum was calculated from the candidate artifact and the documented catalog hash file, if present, matches the artifact you intend to upload.

Block 3 - prove the public route is warm

A catalog is warm only in the limited, useful sense that the public route has successfully served the intended response before players depend on it. It does not mean every CDN edge worldwide is guaranteed pre-populated, nor does it replace load testing.

Write down the exact endpoint instead of “the CDN.” For example:

Catalog URL:
https://cdn.example-game.com/addressables/april-2027/Windows/catalog.json

Bundle base URL:
https://cdn.example-game.com/addressables/april-2027/Windows/

Smoke label:
april-warm-smoke

Use a cache-safe release layout. Immutable, content-addressed bundle names work better than overwriting a constant bundle object. Catalog cache behavior needs an explicit policy; changing a catalog at a stable URL without understanding origin and edge caching is a common route to stale players.

Run a public HTTP request from a network that resembles the player route. Save headers and body separately:

curl --fail --location --silent --show-error \
  --dump-header catalog.headers.txt \
  --output catalog.body.json \
  "https://cdn.example-game.com/addressables/april-2027/Windows/catalog.json"

sha256sum catalog.body.json

A4 requires HTTP 200 after redirects and a SHA-256 match with catalog_sha256. If your CDN sets a trusted response header such as x-content-sha256, save it too. Do not make the header mandatory unless your hosting system actually supports and controls it; the body checksum is the portable evidence.

A3 passes only once the receipt names the route that was requested. A copied profile variable is not enough when the deployed host differs from the intended host.

Block 4 - make an installed player use it

The player path catches the configuration mistake that raw curl cannot: a build may point at a different profile, an old catalog, a local catalog only, a missing label, or incompatible bundle content.

For a development build, add a narrow smoke component. Keep it behind a development flag or a dedicated test scene; do not add a production UI solely for receipt generation.

using System.Collections;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.ResourceManagement.ResourceLocations;

public class AddressablesWarmCatalogSmoke : MonoBehaviour
{
    [SerializeField] private string warmLabel = "april-warm-smoke";

    private IEnumerator Start()
    {
        var init = Addressables.InitializeAsync();
        yield return init;

        if (init.Status != AsyncOperationStatus.Succeeded)
        {
            Debug.LogError("WARM_CATALOG init_failed");
            yield break;
        }

        var locations = Addressables.LoadResourceLocationsAsync(warmLabel);
        yield return locations;

        if (locations.Status != AsyncOperationStatus.Succeeded ||
            locations.Result == null ||
            locations.Result.Count == 0)
        {
            Debug.LogError($"WARM_CATALOG label_failed label={warmLabel}");
            Addressables.Release(locations);
            yield break;
        }

        Debug.Log($"WARM_CATALOG label_ok label={warmLabel} locations={locations.Result.Count}");

        var asset = Addressables.LoadAssetAsync<Object>(locations.Result[0]);
        yield return asset;

        if (asset.Status == AsyncOperationStatus.Succeeded)
        {
            Debug.Log($"WARM_CATALOG asset_ok key={locations.Result[0].PrimaryKey}");
        }
        else
        {
            Debug.LogError($"WARM_CATALOG asset_failed key={locations.Result[0].PrimaryKey}");
        }

        Addressables.Release(asset);
        Addressables.Release(locations);
    }
}

This component does not prove every remote asset loads. It proves one intentionally selected remote label resolves and that at least one addressed asset can be retrieved under the installed player’s actual configuration. Save the device platform, build ID, launch time, network type, the chosen label, and the log lines.

Beginner path - make the first receipt without overbuilding it

If Addressables terminology is new, use this sequence:

1. Pick one harmless remote asset. A small texture, prefab, or configuration asset is enough. Give it the april-warm-smoke label.
2. Confirm it is remote. Check the group’s build and load path. If it is packed into the player, it cannot prove the remote route.
3. Build content using the candidate profile. Locate the platform’s generated catalog in ServerData.
4. Copy the generated catalog path into your evidence. Calculate a SHA-256 hash from it.
5. Upload the exact output. Avoid manually rearranging files after the content build unless the deployment process records that transformation.
6. Request the catalog URL from outside the Unity Editor. Save the response headers and body.
7. Install the build. Launch the test scene or development smoke path on a device or clean machine.
8. File one JSON receipt. Set warm_catalog_ok only after A1 through A5 pass.

The most common beginner mistake is testing the catalog URL in a browser on the same machine that built it. The browser can have a cached response, your machine can have credentials unavailable to players, and the Editor can use different profile values than an installed build. Use a saved response and installed-player output.

Developer path - make the result reviewable and automatable

Working teams should keep the receipt small but machine-readable. The receipt should name source artifacts, not embed entire catalog files. It should preserve enough evidence to answer these questions later:

• Which March capstone allowed this content update?
• Which content build and git revision produced the catalog?
• Which local catalog file did we hash?
• Which public URL did we request?
• What final URL and response status did the CDN return?
• Did the public response equal the built catalog?
• Which player build loaded which remote label?
• Which gate blocked promotion if the answer was no?

Use the following template as a starting point.

Receipt JSON template

{
  "schema": "april_content_update_warm_catalog_receipt_v1",
  "receipt_id": "april-2027-rc01-warm-catalog",
  "created_at_utc": "2027-04-02T18:42:00Z",
  "environment": "staging",
  "release_candidate": "april-content-rc01",
  "git_commit": "REPLACE_WITH_COMMIT",
  "capstone_crosswalk": {
    "capstone_receipt_path": "release-evidence/march-2027/march_capstone_closeout_receipt_v1.json",
    "build_receipt_path": "release-evidence/BUILD_RECEIPT.json",
    "april_content_update_allowed": true
  },
  "addressables_build": {
    "platform": "Windows",
    "profile": "AprilStaging",
    "server_data_path": "ServerData/Windows",
    "catalog_file": "ServerData/Windows/catalog.json",
    "catalog_hash_file": "ServerData/Windows/catalog.hash",
    "catalog_sha256": "REPLACE_WITH_SHA256",
    "addressables_catalog_hash": "REPLACE_WITH_CATALOG_HASH_FILE_CONTENT",
    "smoke_label": "april-warm-smoke",
    "required_content": [
      {
        "file": "ServerData/Windows/remote_assets_8f12c.bundle",
        "content_sha256": "REPLACE_WITH_SHA256"
      }
    ]
  },
  "remote_hosting": {
    "catalog_url": "https://cdn.example-game.com/addressables/april-2027/Windows/catalog.json",
    "bundle_base_url": "https://cdn.example-game.com/addressables/april-2027/Windows/",
    "cdn_provider_or_environment": "REPLACE_WITH_HOSTING_NAME"
  },
  "cdn_smoke": {
    "checked_at_utc": "2027-04-02T18:51:00Z",
    "http_status": 200,
    "final_url": "https://cdn.example-game.com/addressables/april-2027/Windows/catalog.json",
    "response_catalog_sha256": "REPLACE_WITH_SHA256",
    "response_hash_header": null,
    "response_matches_built_catalog": true,
    "headers_file": "catalog.headers.txt",
    "body_file": "catalog.body.json"
  },
  "player_smoke": {
    "checked_at_utc": "2027-04-02T19:07:00Z",
    "player_build_id": "april-content-rc01",
    "device_or_platform": "Windows clean test machine",
    "network": "public test network",
    "label": "april-warm-smoke",
    "location_count": 1,
    "asset_load_status": "succeeded",
    "log_file": "player-warm-smoke.log"
  },
  "gates": {
    "A1_capstone_allowed": "PASS",
    "A2_catalog_hash_pinned": "PASS",
    "A3_remote_path_documented": "PASS",
    "A4_cdn_warm_request": "PASS",
    "A5_player_remote_label": "PASS",
    "A6_receipt_filed": "PASS"
  },
  "warm_catalog_ok": true,
  "reviewed_by": "REPLACE_WITH_RELEASE_OWNER",
  "notes": "Catalog body hash is authoritative when the CDN does not expose a controlled hash header."
}

When A1–A5 pass, cross-link the result in the root BUILD_RECEIPT rather than copying all data into it:

{
  "april_content_update_allowed": true,
  "warm_catalog_receipt": "release-evidence/april-2027/warm-catalog/2027-04-02-rc01/april_content_update_warm_catalog_receipt_v1.json",
  "warm_catalog_ok": true
}

That is the required crosswalk: March owns authorization; the warm receipt owns path proof; BUILD_RECEIPT points to both facts.

Verification script

Save this as verify_april_content_update_warm_catalog.sh, make it executable, and run it from the candidate evidence folder. It verifies the local catalog checksum and public catalog response checksum. It intentionally does not pretend to replace player proof.

#!/usr/bin/env bash
set -euo pipefail

RECEIPT="${1:-april_content_update_warm_catalog_receipt_v1.json}"

command -v jq >/dev/null || { echo "jq is required"; exit 2; }
command -v curl >/dev/null || { echo "curl is required"; exit 2; }
command -v sha256sum >/dev/null || { echo "sha256sum is required"; exit 2; }

allowed="$(jq -r '.capstone_crosswalk.april_content_update_allowed' "$RECEIPT")"
catalog_file="$(jq -r '.addressables_build.catalog_file' "$RECEIPT")"
expected_catalog_sha="$(jq -r '.addressables_build.catalog_sha256' "$RECEIPT")"
catalog_url="$(jq -r '.remote_hosting.catalog_url' "$RECEIPT")"
expected_response_sha="$(jq -r '.cdn_smoke.response_catalog_sha256' "$RECEIPT")"
warm_ok="$(jq -r '.warm_catalog_ok' "$RECEIPT")"

[ "$allowed" = "true" ] || { echo "A1 FAIL: april_content_update_allowed is not true"; exit 1; }
[ -f "$catalog_file" ] || { echo "A2 FAIL: catalog file not found: $catalog_file"; exit 1; }

actual_local_sha="$(sha256sum "$catalog_file" | awk '{print $1}')"
[ "$actual_local_sha" = "$expected_catalog_sha" ] || {
  echo "A2 FAIL: local catalog SHA-256 differs"
  exit 1
}

curl --fail --location --silent --show-error \
  --dump-header catalog.headers.txt \
  --output catalog.body.json \
  "$catalog_url"

actual_remote_sha="$(sha256sum catalog.body.json | awk '{print $1}')"
[ "$actual_remote_sha" = "$expected_response_sha" ] || {
  echo "A4 FAIL: remote response SHA-256 differs"
  exit 1
}

[ "$actual_remote_sha" = "$actual_local_sha" ] || {
  echo "A4 FAIL: remote catalog differs from built catalog"
  exit 1
}

[ "$warm_ok" = "true" ] || {
  echo "A6 FAIL: receipt does not record warm_catalog_ok true"
  exit 1
}

echo "A1 PASS: March capstone allows April update"
echo "A2 PASS: built catalog hash matches receipt"
echo "A4 PASS: CDN catalog response matches built catalog"
echo "A6 PASS: receipt records warm_catalog_ok"
echo "A5 MANUAL: confirm installed-player log and remote label evidence"

On macOS, replace sha256sum with shasum -a 256, or provide a small platform wrapper. In CI, treat the script as a verifier of filed evidence, not as authorization to mark A5 passed. The device path remains a separate artifact.

Smoke paths - CDN and player

Use two smoke paths because they detect different classes of failure.

For the CDN bundle smoke, do not assume a catalog references a human-readable bundle name. Extract the required bundle URL from the generated catalog or deployment manifest appropriate to your Addressables version, then request that exact object. Record its SHA-256 if downloading the complete bundle is practical. For large bundles, record status, content length, immutable cache headers, and a range request only if your CDN and content policy support it.

Proof table - what promotion reviewers need

Scenarios A–G

Scenario A - March passed, catalog response is stale

A1 is green because the March capstone set april_content_update_allowed: true. A2 is green because CI produced the expected catalog. A4 fails because the CDN response hash matches yesterday’s catalog.

Do not downgrade this to a warning. The operational decision is clear: the update is authorized but not warm. Check whether a stable catalog URL has an edge TTL longer than your release policy, whether the origin deployment was incomplete, and whether the CDN purge targeted the correct host and path. Re-run A4 and A5 after correcting delivery.

Scenario B - CDN catalog is correct, installed player sees no label

The public body hash matches. The player prints label_failed. This usually points to a label mismatch, a group built into local content, a player profile that uses another remote load path, or catalog initialization behavior that differs from your test assumption.

Inspect the installed build’s Addressables profile settings and the selected content update workflow. Do not “pass A5” by proving the Editor can load it.

Scenario C - the catalog hash file changed but SHA-256 did not match receipt

Treat this as an artifact identity problem. You may have selected output from a different build, rebuilt in place, or mixed deployment files from two candidates. Rebuild into a clean, candidate-specific directory and regenerate the receipt. The content hash lockfiles article is the companion for preventing this class of branch churn in CI.

Scenario D - browser works, curl gets 403

The browser may carry authentication, use a different route, follow a service-worker cache, or hide a redirect. A public player without those credentials is closer to the curl result. Document whether the environment is intentionally authenticated. For an actual player-facing endpoint, a 403 is an A4 failure.

Scenario E - player succeeds only after a previous launch

A prior launch can leave catalog or bundle data in cache. Clear the app’s Addressables-related cache according to your platform test procedure, reinstall when appropriate, and rerun on a clean state. File the clean-device result. The first-load path is precisely the risk this receipt is meant to expose.

Scenario F - CDN response is 200 but returns HTML

Status alone is not content proof. A fallback page, gateway error page, or hosting redirect can return 200. The catalog body SHA-256 mismatch catches it. Save the response content type and body file; correct the route rather than accepting a superficial HTTP success.

Scenario G - the capstone latch is false but a developer wants to warm anyway

You can run a non-promotional technical experiment in a clearly separate environment if team policy permits it. You cannot mark an April release candidate as approved or set warm_catalog_ok: true for promotion. A1 is a release governance gate, not a networking diagnostic.

Common mistakes

• Treating april_content_update_allowed as a networking check. It authorizes work after the March capstone; it does not establish public content availability.
• Using only the Addressables .hash file. Preserve it, but also calculate a conventional SHA-256 checksum for independent response comparison.
• Testing a development server instead of the configured remote host. A local server can prove a catalog is syntactically valid while proving nothing about release hosting.
• Hashing one catalog and uploading another. Record candidate IDs and paths; do not reuse a mutable ServerData folder across candidates.
• Using an Editor test as player evidence. A player build can have different initialization, profile values, cache state, platform folders, and permissions.
• Selecting a local-only label. The label must include remote content or the test has no delivery value.
• Marking A6 before filing response and player artifacts. The receipt is not a memory aid; it is reviewable evidence.
• Mixing production drift checks into this receipt. The production validation loop should own repeated patch-week observations.

Troubleshooting

“The script says local and remote hashes differ.” First confirm the receipt’s catalog_file belongs to the candidate deployment. Then compare the raw remote body, not a browser-rendered view. Check CDN cache rules, origin deployment completion, redirects, compression handling, and whether your endpoint serves a different platform catalog.

“The catalog endpoint redirects.” Save the final URL after curl --location. Redirects can be acceptable if they are intentional and reachable from target clients. Record them because signed URLs, region redirects, or an HTTP-to-HTTPS policy can change player behavior.

“The installed player cannot initialize Addressables.” Check the runtime data path, Addressables initialization settings, platform-specific permissions, and whether the player build includes the expected runtime configuration. Capture the full relevant player log around initialization.

“The label resolves but loading the first asset fails.” Verify dependencies, bundle availability, platform compatibility, and whether the selected asset is valid for the test platform. Add the failed primary key to the receipt notes; do not replace it with an easier asset without documenting why.

“Our CDN cannot supply a hash header.” That is normal. Save headers for status and cache evidence, then calculate the SHA-256 of the downloaded body. The receipt template allows response_hash_header: null.

“Our catalog is compressed or transformed by hosting.” Verify the checksum against the bytes Unity will consume. If your CDN transparently compresses transfer encoding but returns equivalent decoded content to the client, ensure your tool’s output represents the decoded response consistently. Prefer a deployment design where catalog bytes are served predictably and artifact comparisons are unambiguous.

For a broader pre-promotion routine, pair this evidence with the Wednesday demo build smoke ritual and the Thursday BUILD_RECEIPT row review ritual. Those articles cover release cadence around the warm catalog proof; they do not replace it.

Key takeaways

1. A passed March capstone is required authorization, but it is not proof that an Addressables remote catalog is reachable.
2. A1 consumes april_content_update_allowed from the March receipt; it should never be invented in the April receipt.
3. Pin both the generated Addressables catalog hash file, when present, and an independent SHA-256 checksum of the built catalog.
4. Document the exact public catalog URL and bundle base URL before calling a route “the CDN.”
5. A 200 response is insufficient; verify that the downloaded catalog body hash equals the candidate artifact hash.
6. Use an installed player and a deliberately remote smoke label to prove the player path.
7. Keep CDN proof and player proof separate because each catches failures the other cannot.
8. Store headers, body, logs, and JSON in one candidate-specific evidence folder.
9. Set BUILD_RECEIPT.warm_catalog_ok: true only after A1 through A6 pass.
10. Use the production drift loop for recurring patch-week verification, not as a substitute for this one-evening handoff.
11. Keep promotion blocked when any gate is failed or not run, even if the catalog appears to work on a developer machine.
12. Forward the completed receipt into future automation: blog #8’s planned jq April weekly review can summarize receipts, while the planned Guide #49, Course #287, and Help #49 can link to the right step without duplicating the whole workflow.

FAQ

What is a warm catalog in Unity Addressables?

In this workflow, a warm catalog is a remote catalog that has been requested through the actual public CDN route and then used by an installed player to resolve a selected remote label. It is operational evidence, not a claim that every CDN edge or every bundle has been preloaded globally.

Does april_content_update_allowed: true mean we can ship immediately?

No. It means the March capstone allowed the April content-update process to proceed. A2–A6 still prove the candidate artifact, public route, player path, and filed evidence.

Why calculate SHA-256 if Addressables already creates a catalog hash?

The generated Addressables hash file participates in Addressables content-update behavior. A SHA-256 checksum gives your release evidence an independent, standard way to compare the exact local catalog bytes with the exact CDN response bytes.

Can we run the player smoke in the Unity Editor?

Use it as a developer diagnostic if helpful, but do not use it for A5. The required evidence is an installed build on a target-like machine or device because runtime configuration, cache state, and networking can differ.

Must the CDN return an x-content-sha256 header?

No. If you control such a header, record it as extra evidence. The portable requirement is to download the catalog body and calculate its SHA-256, then compare it with the candidate artifact.

What if the smoke label has several locations?

Record the location count and load one deterministic, small asset appropriate to your test. If the release risk requires it, expand the player smoke to load each critical location, but keep that expanded scope documented rather than implying a one-asset smoke proves the whole update.

Is this the same as validating catalog drift during patch week?

No. This receipt is a one-evening, candidate-specific proof immediately after authorization. The remote catalog drift validation loop is the right place for repeated production observations and patch-week response changes.

Related reads

• Friday March Capstone Closeout BUILD_RECEIPT Row Review - Ten Minutes Before April Content Update Upload
• Addressables Remote Catalog Drift - Unity 6 Production Validation Loop for Patch Weeks
• Build Content Hash Lockfiles - Unity Addressables CI Artifact Survives Branch Churn
• 7-Day Unity Addressables Invalid Key Audit Challenge - Fest Content Update
• We Recovered a Remote Catalog Orphan After April Content Update Receipt Passed — when warm GREEN still leaves ghost CDN hashes
• jq Gate Sketch for april_content_update Weekly Catalog Row Diff — Monday weekly catalog identity after warm evenings
• Wednesday Demo Build Smoke Ritual - Fifteen Minutes Before Fest Branch Promotion
• Thursday BUILD_RECEIPT Row Review Ritual - Ten Minutes After Wednesday Smoke — fest cousin after demo smoke
• Thursday Content Update BUILD_RECEIPT Row Review After Wednesday Warm Catalog — Addressables promote latch after warm
• Your First BUILD_RECEIPT JSON and Upload Log - One Evening

Closing

A remote catalog upload is not the end of an April content update. It is the beginning of a delivery path that must work for someone other than the machine that built it.

Keep the separation sharp: Friday’s March capstone decides whether April work is allowed. This one-evening receipt proves the candidate catalog bytes, public CDN path, and installed player behavior after that decision. When A1–A6 are filed together, warm_catalog_ok means something concrete: the release owner can trace the permission latch, catalog hash, content hash, public response, player label, and review artifact without reconstructing the update from chat messages or stale browser tabs. The next morning’s honesty check is the Thursday content-update row review—warm GREEN alone must not set content_update_promote_allowed.

If Summer Sale players still fetch dead hashes after that GREEN latch, do not pretend the warm evening was a lie—run the orphan recovery pattern in We Recovered a Remote Catalog Orphan After April Content Update Receipt Passed (R1–R6, remote_catalog_orphan_recovery_ok). For week-over-week catalog hash honesty after authorize, run jq april_content_update weekly catalog row diff (J1–J6, april_content_update_weekly_ok).