fix(sdk): re-plan after commit for image puts to surface v1.49 variants

The gateway generates image variants AT COMMIT TIME (parent gateway
change Section 5 — prepareStagedAssetVariants runs before the
activation txn opens). The plan response that funds DeployResult.assets
is built BEFORE commit, so its asset_entries[].asset_ref doesn't carry
variant fields. Consumers calling r.assets.put or
r.project(id).apply({ assets: { put: [<image>] } }) saw an AssetRef
without variants/blurhash/width_px/etc. for first uploads — even though
the gateway DID generate them and bytes were live.

Fix: in applyOnce, after the commit succeeds and result.assets is
built, do a dry-run re-plan with the same spec if any put entry has an
image/* content_type. The recheck hits /apply/v1/plans?dry_run=true; the
gateway looks up internal.blob_image_variants by source_sha256, builds
an AssetImageData, threads it through buildAssetRefForPlan, and returns
asset_entries with the full variant shape. The SDK merges those fields
into the existing manifest entries.

Dry-run keeps the recheck cheap: no plan_id or operation_id rows are
created. The recheck is wrapped in try/catch so a failure can't break a
successful apply — variants stay empty rather than the apply throwing.

Also fixes a test assertion that compared display_url (wire mutable) to
the SDK's cdnUrl alias (wire immutable). Non-HEIC parity is:
  ref.display_url           === ref.cdnMutableUrl
  ref.display_immutable_url === ref.cdnUrl

Both image-variant e2e tests now pass against api.run402.com.

Closes asset-image-variants-client tasks 9.1 / 9.2 strictly.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: MajorTal

fullstack-integration.test.ts

@@ -767,8 +767,11 @@ describe("Run402 full-stack integration (live API, no mocks)", { timeout: 900_00
     assert.equal(putRef.variants.medium?.format, "webp");
     assert.equal(putRef.variants.large?.format, "webp");
     assert.equal(putRef.variants.display_jpeg, undefined, "non-HEIC sources must NOT include display_jpeg");
-    // Non-HEIC: display_url should equal cdn_url (browser-renderable directly).
-    assert.equal(putRef.display_url, putRef.cdnUrl ?? putRef.cdn_immutable_url ?? undefined, "non-HEIC display_url should equal cdn_url");
+    // Non-HEIC: display_url equals the wire's mutable cdn_url (which the
+    // SDK exposes as `cdnMutableUrl` — `cdnUrl` aliases the immutable
+    // form). display_immutable_url equals the SDK's `cdnUrl`.
+    assert.equal(putRef.display_url, putRef.cdnMutableUrl, "non-HEIC display_url should equal the wire cdn_url (mutable form)");
+    assert.equal(putRef.display_immutable_url, putRef.cdnUrl, "non-HEIC display_immutable_url should equal the wire cdn_immutable_url");
     // SDK convenience getters are present for image refs.
     assert.equal(putRef.thumbUrl, putRef.variants.thumb?.cdn_url);
     assert.equal(putRef.displayUrl, putRef.display_url);

sdk/src/namespaces/deploy.ts

@@ -603,6 +603,58 @@ async function applyOnce(
   // Release-only applies leave `result.assets` undefined.
   if (plan.asset_entries && plan.asset_entries.length > 0) {
     result.assets = buildAssetManifestFromPlanEntries(plan.asset_entries);
+
+    // v1.49 image-variant follow-up: variants are generated AT COMMIT TIME
+    // (parent gateway change Section 5 — `prepareStagedAssetVariants` runs
+    // before the activation txn opens). The plan that funded `result.assets`
+    // was built BEFORE commit, so its `asset_entries[].asset_ref` doesn't
+    // include the variant fields (the gateway only threads `image_data`
+    // through `buildAssetRefForPlan` for SHAs that ALREADY have variants
+    // in `internal.blob_image_variants`).
+    //
+    // For image puts, do a dry-run re-plan with the same spec. Bytes are
+    // now in CAS (the commit just landed) AND variant rows exist in the
+    // DB. The new plan response surfaces the variants. Dry-run keeps it
+    // cheap: no new plan_id or operation_id rows are created.
+    //
+    // Best-effort: a re-plan failure shouldn't fail the apply. The bytes
+    // are committed, the release is live, and the variant fields are
+    // strictly additive — leaving them empty when the recheck errors is
+    // worse than failing the apply.
+    const hasImagePut = spec.assets?.put?.some((entry) => {
+      const ct = ("content_type" in entry && typeof entry.content_type === "string")
+        ? entry.content_type
+        : "";
+      return ct.startsWith("image/");
+    });
+    if (hasImagePut) {
+      try {
+        const { plan: recheck } = await planInternal(client, spec, undefined, true);
+        if (recheck.asset_entries && recheck.asset_entries.length > 0) {
+          for (const recheckEntry of recheck.asset_entries) {
+            const existing = result.assets.byKey[recheckEntry.key];
+            if (!existing) continue;
+            const ref = recheckEntry.asset_ref;
+            if (ref.width_px !== undefined) existing.width_px = ref.width_px;
+            if (ref.height_px !== undefined) existing.height_px = ref.height_px;
+            if (ref.blurhash !== undefined) existing.blurhash = ref.blurhash;
+            if (ref.variant_spec_version !== undefined) {
+              existing.variant_spec_version = ref.variant_spec_version;
+            }
+            if (ref.display_url !== undefined) existing.display_url = ref.display_url;
+            if (ref.display_immutable_url !== undefined) {
+              existing.display_immutable_url = ref.display_immutable_url;
+            }
+            if (ref.variants !== undefined) existing.variants = ref.variants;
+          }
+        }
+      } catch {
+        // Best-effort: leave variant fields unpopulated rather than
+        // failing a successful apply. Consumers can re-call
+        // `r.assets.put` with the same bytes (dedup) to trigger the
+        // plan-time surfacing if variants are missing.
+      }
+    }
   }
 
   return result;