@run402/sdk 2.2.0 → 2.3.1

package/dist/namespaces/deploy.js

@@ -362,8 +362,29 @@ function requireNonEmptyStringQueryOption(value, label, context) {
     return value;
 }
 // ─── Internal pipeline ───────────────────────────────────────────────────────
+/**
+ * Compute the sorted set of slice kinds the spec carried. Surfaces on
+ * `commit.phase` and `ready` events so agents can group per-phase
+ * telemetry by slice category. `assets` slice → `"asset"`; any of
+ * `database` / `functions` / `site` → `"release"`. Order is stable
+ * (release before asset).
+ */
+function deriveSliceKinds(spec) {
+    // Guard against non-object spec — the validate phase throws below
+    // (INVALID_SPEC), but this is called before validation in applyOnce so
+    // we must not blow up first.
+    if (!spec || typeof spec !== "object")
+        return [];
+    const set = new Set();
+    if (spec.database || spec.functions || spec.site)
+        set.add("release");
+    if (spec.assets)
+        set.add("asset");
+    return [...set].sort((a, b) => (a === "release" ? -1 : 1));
+}
 async function applyOnce(client, spec, opts, emit) {
     const allowWarningCodes = normalizeAllowWarningCodes(opts.allowWarningCodes);
+    const sliceKinds = deriveSliceKinds(spec);
     emit({ type: "plan.started" });
     const { plan, byteReaders } = await planInternal(client, spec, opts.idempotencyKey);
     emit({ type: "plan.diff", diff: plan.diff });
@@ -383,16 +404,79 @@ async function applyOnce(client, spec, opts, emit) {
         // event and resolve before we hit upload.
     }
     await uploadMissing(client, spec.project, plan.missing_content, byteReaders, emit);
-    emit({ type: "commit.phase", phase: "validate", status: "started" });
+    emit({
+        type: "commit.phase",
+        phase: "validate",
+        status: "started",
+        ...(sliceKinds.length > 0 ? { slice_kinds: sliceKinds } : {}),
+    });
     const { planId } = requirePersistedPlan(plan, "applying deploy");
     const commit = await commitInternal(client, planId, opts.idempotencyKey);
-    const result = await pollUntilReady(client, commit, plan.diff, plan.warnings, emit, spec.project);
+    const result = await pollUntilReady(client, commit, plan.diff, plan.warnings, emit, spec.project, sliceKinds);
     // v1.48 unified-apply: thread the plan response's `asset_entries[]` back
     // into DeployResult.assets so callers reading `result.assets.byKey[key]`
     // get the gateway-authoritative `AssetRef` envelope (URLs, SRI, etag).
     // 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;
 }
@@ -873,6 +957,7 @@ async function uploadMissing(client, projectId, presence, byteReaders, emit) {
             label: reader?.label ?? p.sha256,
             sha256: p.sha256,
             reason: "present",
+            ...(reader?.slice ? { slice_kind: reader.slice } : {}),
         });
     }
     // Filter to refs the gateway reported as missing for this project.
@@ -925,6 +1010,7 @@ async function uploadMissing(client, projectId, presence, byteReaders, emit) {
             sha256: session.sha256,
             done,
             total,
+            ...(reader.slice ? { slice_kind: reader.slice } : {}),
         });
     }
     // Plan-level finalize — marks the plan committed in the deploy_plans
@@ -1040,7 +1126,7 @@ async function putToS3(fetchFn, url, body, checksumBase64, partNumber) {
     }
     return res.headers.get("etag");
 }
-async function pollUntilReady(client, commit, diff, warnings, emit, projectId) {
+async function pollUntilReady(client, commit, diff, warnings, emit, projectId, sliceKinds = []) {
     if (commit.status === "failed") {
         throw translateGatewayError(commit.error, "commit", null, commit.operation_id);
     }
@@ -1054,7 +1140,12 @@ async function pollUntilReady(client, commit, diff, warnings, emit, projectId) {
                 context: "committing deploy",
             });
         }
-        emit({ type: "ready", releaseId: commit.release_id, urls: commit.urls });
+        emit({
+            type: "ready",
+            releaseId: commit.release_id,
+            urls: commit.urls,
+            ...(sliceKinds.length > 0 ? { slice_kinds: sliceKinds } : {}),
+        });
         return {
             release_id: commit.release_id,
             operation_id: commit.operation_id,
@@ -1065,9 +1156,16 @@ async function pollUntilReady(client, commit, diff, warnings, emit, projectId) {
     }
     const opHeaders = projectId ? await apikeyHeaders(client, projectId) : {};
     const initialSnapshot = await client.request(`/apply/v1/operations/${encodeURIComponent(commit.operation_id)}`, { headers: opHeaders, context: "fetching deploy operation" });
-    return await pollSnapshotUntilReady(client, initialSnapshot, diff, warnings, emit, projectId);
-}
-async function pollSnapshotUntilReady(client, initial, diff, warnings, emit, projectId) {
+    return await pollSnapshotUntilReady(client, initialSnapshot, diff, warnings, emit, projectId, sliceKinds);
+}
+async function pollSnapshotUntilReady(client, initial, diff, warnings, emit, projectId, sliceKinds = []) {
+    // Helper to spread slice_kinds onto every commit.phase / ready emit so
+    // agents grouping per-slice telemetry don't need to track the apply's
+    // spec separately. The low-level commit/upload helpers that pass no
+    // sliceKinds get an empty array → field is omitted from events.
+    const withSliceKinds = (ev) => sliceKinds.length > 0
+        ? { ...ev, slice_kinds: sliceKinds }
+        : ev;
     let snapshot = initial;
     const opHeaders = projectId ? await apikeyHeaders(client, projectId) : {};
     let lastPhaseEmitted = null;
@@ -1107,7 +1205,7 @@ async function pollSnapshotUntilReady(client, initial, diff, warnings, emit, pro
             return;
         if (nextPhase !== undefined && prev.phase === nextPhase)
             return;
-        emit({ type: "commit.phase", phase: prev.phase, status: closeStatus });
+        emit(withSliceKinds({ type: "commit.phase", phase: prev.phase, status: closeStatus }));
     };
     while (true) {
         if (lastPhaseEmitted !== snapshot.status) {
@@ -1115,7 +1213,7 @@ async function pollSnapshotUntilReady(client, initial, diff, warnings, emit, pro
             if (ev) {
                 if (ev.type === "commit.phase")
                     closePreviousPhase(ev.phase);
-                emit(ev);
+                emit(withSliceKinds(ev));
                 lastPhaseEmitted = snapshot.status;
             }
             // If `ev` is null (status not in the phase map, e.g. "ready"), leave
@@ -1133,7 +1231,7 @@ async function pollSnapshotUntilReady(client, initial, diff, warnings, emit, pro
                 });
             }
             closePreviousPhase();
-            emit({ type: "ready", releaseId: snapshot.release_id, urls: snapshot.urls });
+            emit(withSliceKinds({ type: "ready", releaseId: snapshot.release_id, urls: snapshot.urls }));
             return {
                 release_id: snapshot.release_id,
                 operation_id: snapshot.operation_id,
@@ -1215,12 +1313,18 @@ async function startInternal(client, spec, opts) {
             reason: plan.payment_required.reason,
         });
     }
+    const sliceKinds = deriveSliceKinds(spec);
     const resultPromise = (async () => {
         await uploadMissing(client, spec.project, plan.missing_content, byteReaders, emit);
-        emit({ type: "commit.phase", phase: "validate", status: "started" });
+        emit({
+            type: "commit.phase",
+            phase: "validate",
+            status: "started",
+            ...(sliceKinds.length > 0 ? { slice_kinds: sliceKinds } : {}),
+        });
         const { planId } = requirePersistedPlan(plan, "starting deploy");
         const commit = await commitInternal(client, planId, opts.idempotencyKey);
-        return await pollUntilReady(client, commit, plan.diff, plan.warnings, emit, spec.project);
+        return await pollUntilReady(client, commit, plan.diff, plan.warnings, emit, spec.project, sliceKinds);
     })();
     // Avoid an unhandled-rejection at construction time. Consumers must call
     // .result() to actually observe the error.
@@ -2033,7 +2137,13 @@ function invalidSecretSpec(message, resource) {
 }
 async function normalizeReleaseSpec(client, spec) {
     const byteReaders = new Map();
-    const remember = (resolved) => {
+    // Slice-tagged `remember`. Each slice category creates its own remember
+    // closure so the registered reader carries `reader.slice = "release" |
+    // "asset"`. On cross-kind dedup (same SHA from both a release-bound
+    // slice and the asset slice) the value escalates to `"mixed"`. This
+    // value surfaces on `content.upload.*` events so agents can group
+    // upload telemetry by slice kind.
+    const makeRemember = (slice) => (resolved) => {
         // Propagate the final content-type onto the deferred reader so the CAS
         // upload session can declare it correctly. Callers may set
         // ref.contentType *after* resolveContent returns (e.g. normalizeFileSet
@@ -2042,18 +2152,25 @@ async function normalizeReleaseSpec(client, spec) {
             resolved.reader.contentType = resolved.ref.contentType;
         }
         if (!byteReaders.has(resolved.ref.sha256)) {
+            resolved.reader.slice = slice;
             byteReaders.set(resolved.ref.sha256, resolved.reader);
         }
         else {
             // Already remembered — but if the existing reader has no contentType
-            // and we just learned it, fill it in.
+            // and we just learned it, fill it in. Also escalate slice tag when
+            // the second registration comes from a different kind.
             const existing = byteReaders.get(resolved.ref.sha256);
             if (resolved.ref.contentType && !existing.contentType) {
                 existing.contentType = resolved.ref.contentType;
             }
+            if (existing.slice && existing.slice !== slice && existing.slice !== "mixed") {
+                existing.slice = "mixed";
+            }
         }
         return resolved.ref;
     };
+    const rememberRelease = makeRemember("release");
+    const rememberAsset = makeRemember("asset");
     const normalized = { project: spec.project };
     if (spec.base)
         normalized.base = spec.base;
@@ -2074,19 +2191,19 @@ async function normalizeReleaseSpec(client, spec) {
             db.zero_downtime = spec.database.zero_downtime;
         }
         if (spec.database.migrations && spec.database.migrations.length > 0) {
-            db.migrations = await Promise.all(spec.database.migrations.map(async (m) => normalizeMigration(client, spec.project, m, remember)));
+            db.migrations = await Promise.all(spec.database.migrations.map(async (m) => normalizeMigration(client, spec.project, m, rememberRelease)));
         }
         normalized.database = db;
     }
     if (spec.functions) {
         const fns = {};
         if (spec.functions.replace) {
-            fns.replace = await normalizeFunctionMap(spec.functions.replace, remember);
+            fns.replace = await normalizeFunctionMap(spec.functions.replace, rememberRelease);
         }
         if (spec.functions.patch) {
             fns.patch = {};
             if (spec.functions.patch.set) {
-                fns.patch.set = await normalizeFunctionMap(spec.functions.patch.set, remember);
+                fns.patch.set = await normalizeFunctionMap(spec.functions.patch.set, rememberRelease);
             }
             if (spec.functions.patch.delete)
                 fns.patch.delete = spec.functions.patch.delete;
@@ -2096,7 +2213,7 @@ async function normalizeReleaseSpec(client, spec) {
     if (spec.site) {
         const publicPaths = "public_paths" in spec.site ? spec.site.public_paths : undefined;
         if ("replace" in spec.site && spec.site.replace) {
-            const map = await normalizeFileSet(spec.site.replace, remember);
+            const map = await normalizeFileSet(spec.site.replace, rememberRelease);
             normalized.site = {
                 replace: map,
                 ...(publicPaths ? { public_paths: publicPaths } : {}),
@@ -2105,7 +2222,7 @@ async function normalizeReleaseSpec(client, spec) {
         else if ("patch" in spec.site && spec.site.patch) {
             const patch = {};
             if (spec.site.patch.put) {
-                patch.put = await normalizeFileSet(spec.site.patch.put, remember);
+                patch.put = await normalizeFileSet(spec.site.patch.put, rememberRelease);
             }
             if (spec.site.patch.delete)
                 patch.delete = spec.site.patch.delete;
@@ -2123,7 +2240,7 @@ async function normalizeReleaseSpec(client, spec) {
     // register a byte-reader; emit the wire-shaped `AssetPutEntry[]`.
     // Cross-kind SHA dedup is automatic via the shared `byteReaders` map.
     if (spec.assets) {
-        normalized.assets = await normalizeAssetSlice(spec.assets, remember);
+        normalized.assets = await normalizeAssetSlice(spec.assets, rememberAsset);
     }
     return { normalized, byteReaders };
 }
@@ -2186,20 +2303,41 @@ function buildAssetManifestFromPlanEntries(entries) {
     let bytesUploaded = 0;
     let bytesReused = 0;
     for (const entry of entries) {
+        const ref = entry.asset_ref;
         const e = {
             key: entry.key,
             sha256: entry.sha256,
             size_bytes: entry.size_bytes,
             content_type: entry.content_type,
             visibility: entry.visibility,
-            url: entry.asset_ref.url,
-            immutable_url: entry.asset_ref.immutable_url,
-            cdn_url: entry.asset_ref.cdn_url,
-            cdn_immutable_url: entry.asset_ref.cdn_immutable_url,
-            sri: entry.asset_ref.sri,
-            etag: entry.asset_ref.etag,
-            content_digest: entry.asset_ref.content_digest,
+            url: ref.url,
+            immutable_url: ref.immutable_url,
+            cdn_url: ref.cdn_url,
+            cdn_immutable_url: ref.cdn_immutable_url,
+            sri: ref.sri,
+            etag: ref.etag,
+            content_digest: ref.content_digest,
         };
+        // v1.49+ image-variant pass-through. Only emitted when the gateway
+        // returned them (image MIMEs ≥320×320; HEIC/HEIF sources also include
+        // `display_jpeg`). Pre-v1.49 plan responses omit these fields entirely
+        // and the manifest entry stays bytewise-identical to before.
+        if (ref.width_px !== undefined)
+            e.width_px = ref.width_px;
+        if (ref.height_px !== undefined)
+            e.height_px = ref.height_px;
+        if (ref.blurhash !== undefined)
+            e.blurhash = ref.blurhash;
+        if (ref.variant_spec_version !== undefined) {
+            e.variant_spec_version = ref.variant_spec_version;
+        }
+        if (ref.display_url !== undefined)
+            e.display_url = ref.display_url;
+        if (ref.display_immutable_url !== undefined) {
+            e.display_immutable_url = ref.display_immutable_url;
+        }
+        if (ref.variants !== undefined)
+            e.variants = ref.variants;
         list.push(e);
         byKey[entry.key] = e;
         manifest[entry.key] = e;