@expo/build-tools 21.0.1 → 21.0.3

package/dist/steps/functions/maestroScreenshots.js

@@ -9,10 +9,18 @@ exports.computePureFailureFlowNames = computePureFailureFlowNames;
 exports.selectFailureScreenshots = selectFailureScreenshots;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
-// Maestro failure screenshot: `screenshot-[shard-N-]❌-<epochMillis>-(<flowName>).png`.
+// pre-v2.7.0 (Maestro <= 2.6.x): failure screenshots are flat files named
+// `screenshot-[shard-N-]❌-<epochMillis>-(<flowName>).png` directly in the session dir.
 // The flow name may contain parentheses, so anchor on the `-(` after the epoch and the
-// `).png` suffix rather than scanning for parens.
+// `).png` suffix rather than scanning for parens. Remove this path once the build fleet is
+// entirely on Maestro >= 2.7.0.
 const FAILURE_SCREENSHOT_PATTERN = /^screenshot-(?:shard-\d+-)?❌-(\d+)-\((.+)\)\.png$/u;
+// Maestro >= 2.7.0 bundle layout. Each flow gets its own dir under the session dir, with step
+// screenshots under `screenshots/` named `step-<NNN>-<slug>.png` (NNN is a 1-based, zero-padded
+// monotonic step sequence). Under the CLI (no `--analyze`) only failed/warned steps produce one.
+const STEP_SCREENSHOTS_DIRNAME = 'screenshots';
+const STEP_SCREENSHOT_PATTERN = /^step-(\d+)(?:-.*)?\.png$/;
+// pre-v2.7.0: parses the legacy flat failure-screenshot filename.
 function parseFailureScreenshotFilename(filename) {
     const match = filename.match(FAILURE_SCREENSHOT_PATTERN);
     if (!match) {
@@ -27,61 +35,186 @@ function parseFailureScreenshotFilename(filename) {
         capturedAtMs,
     };
 }
-// Scans every debug dir under testsDirectory whose mtime is recent enough (mtime-based to cover
-// the maestro <2.5.0 bug that splits one invocation across two dirs), then keeps only screenshots
-// whose own capturedAtMs is at/after capturedSinceMs. Never throws: an unreadable dir is logged
-// and skipped so a screenshot harvest can't affect the maestro step outcome.
+// Harvests one attempt's failure screenshots from the maestro debug output. Walks each session
+// dir under testsDirectory whose mtime is recent enough (mtime-based to also cover the maestro
+// <2.5.0 bug that splits one invocation across two dirs). Within a session dir, a child is either
+// a flat pre-v2.7.0 screenshot file or a Maestro >= 2.7.0 per-flow bundle dir — the single
+// structural seam below. Never throws: an unreadable dir/file is logged and skipped so a
+// screenshot harvest can't affect the maestro step outcome.
 async function harvestFailureScreenshotsAsync(args) {
     // Gate dirs by mtime floored to the second, so a dir created within the same second as the
-    // attempt start isn't stat'd below the baseline. The exact capturedAtMs gate below is what
+    // attempt start isn't stat'd below the baseline. The exact capturedAtMs gate per file is what
     // prevents mis-attributing an earlier attempt's screenshot.
     const dirSinceMtimeMs = Math.floor(args.capturedSinceMs / 1000) * 1000;
-    let entries;
+    // Bundle dir names already have '/' -> '_'; normalize the JUnit names the same way to match.
+    const normalizedFailedFlowNames = new Set([...args.failedFlowNames].map(normalizeFlowName));
+    let sessionEntries;
     try {
-        entries = await promises_1.default.readdir(args.testsDirectory, { withFileTypes: true });
+        sessionEntries = await promises_1.default.readdir(args.testsDirectory, { withFileTypes: true });
     }
     catch (err) {
         args.logger.info({ err }, `Skipping screenshot harvest: cannot read ${args.testsDirectory}.`);
         return [];
     }
-    const results = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
+    const legacyShots = [];
+    const bundleShots = [];
+    for (const sessionEntry of sessionEntries) {
+        if (!sessionEntry.isDirectory()) {
             continue;
         }
-        const dirPath = path_1.default.join(args.testsDirectory, entry.name);
-        let filenames;
+        const sessionDir = path_1.default.join(args.testsDirectory, sessionEntry.name);
+        let children;
         try {
-            if ((await promises_1.default.stat(dirPath)).mtimeMs < dirSinceMtimeMs) {
+            if ((await promises_1.default.stat(sessionDir)).mtimeMs < dirSinceMtimeMs) {
                 continue;
             }
-            filenames = await promises_1.default.readdir(dirPath);
+            children = await promises_1.default.readdir(sessionDir, { withFileTypes: true });
         }
         catch (err) {
-            args.logger.info({ err }, `Skipping unreadable debug dir ${dirPath}.`);
+            args.logger.info({ err }, `Skipping unreadable debug dir ${sessionDir}.`);
             continue;
         }
-        for (const filename of filenames) {
-            const parsed = parseFailureScreenshotFilename(filename);
-            // Re-check capture time per file: a dir's mtime can advance after this attempt began (or
-            // fall within the floored-second dir baseline), so the dir gate alone would re-attribute an
-            // earlier attempt's screenshot to this one.
-            if (parsed === null || parsed.capturedAtMs < args.capturedSinceMs) {
-                continue;
+        for (const child of children) {
+            if (child.isDirectory()) {
+                // Maestro >= 2.7.0: a per-flow bundle dir.
+                const shot = await harvestFromBundleAsync({
+                    bundleDir: path_1.default.join(sessionDir, child.name),
+                    bundleName: child.name,
+                    normalizedFailedFlowNames,
+                    capturedSinceMs: args.capturedSinceMs,
+                    attemptIndex: args.attemptIndex,
+                    logger: args.logger,
+                });
+                if (shot !== null) {
+                    bundleShots.push(shot);
+                }
             }
-            results.push({
-                fileAbsPath: path_1.default.join(dirPath, filename),
-                displayName: `Failure Screenshot: ${parsed.flowName} (attempt ${args.attemptIndex + 1})`,
-                metadata: {
-                    kind: 'maestro-test-screenshot',
-                    flowName: parsed.flowName,
+            else {
+                // pre-v2.7.0: a flat failure screenshot file in the session dir.
+                const shot = harvestLegacyFlatShot({
+                    fileName: child.name,
+                    sessionDir,
+                    capturedSinceMs: args.capturedSinceMs,
                     attemptIndex: args.attemptIndex,
-                    capturedAtMs: parsed.capturedAtMs,
-                },
-            });
+                });
+                if (shot !== null) {
+                    legacyShots.push(shot);
+                }
+            }
+        }
+    }
+    // The website shows one screenshot per (flow, attempt). Two v2.7.0 bundle dirs can resolve to
+    // the same flow — a collision dir (`<flow>-2`) or a duplicate flow name — so keep the latest.
+    // Legacy shots need no dedupe: a flat filename is emitted once per failed flow, so there is no
+    // `<flow>-2` collision to collapse (and deduping them would change historical behavior).
+    return [...legacyShots, ...dedupeBundleShotsByFlowName(bundleShots)];
+}
+// Maestro >= 2.7.0: resolve a bundle dir to its owning failed flow and return that flow's failure
+// screenshot — the highest-numbered step in `screenshots/`. A required failure halts the flow, so
+// the failed step is normally the last (highest-numbered) captured step; earlier warned steps have
+// lower numbers. Best-effort limitation: without reading Maestro's per-command JSON we can't tell a
+// failed-step frame from a warned-step frame, so if the failing command captured nothing (e.g. a
+// non-visible command like runScript) but an earlier optional step warned, we return that warned
+// frame instead. Returns null when the bundle isn't a failed flow, its name is ambiguous, or it has
+// no usable step screenshot. Never throws.
+async function harvestFromBundleAsync(args) {
+    const flowName = resolveBundleFlowName(args.bundleName, args.normalizedFailedFlowNames);
+    if (flowName === null) {
+        return null;
+    }
+    const screenshotsDir = path_1.default.join(args.bundleDir, STEP_SCREENSHOTS_DIRNAME);
+    let filenames;
+    try {
+        filenames = await promises_1.default.readdir(screenshotsDir);
+    }
+    catch {
+        // No screenshots/ dir — e.g. the flow failed on a non-visible command, which captures none.
+        return null;
+    }
+    let best = null;
+    for (const filename of filenames) {
+        const match = filename.match(STEP_SCREENSHOT_PATTERN);
+        if (match === null) {
+            continue; // final.png and any non-step file
+        }
+        const stepIndex = Number(match[1]);
+        const fileAbsPath = path_1.default.join(screenshotsDir, filename);
+        let capturedAtMs;
+        try {
+            capturedAtMs = Math.round((await promises_1.default.stat(fileAbsPath)).mtimeMs);
+        }
+        catch (err) {
+            args.logger.info({ err }, `Skipping unreadable screenshot ${fileAbsPath}.`);
+            continue;
+        }
+        if (capturedAtMs < args.capturedSinceMs) {
+            continue; // a prior attempt's frame (bundle dir touched later than this attempt started)
+        }
+        if (best === null || stepIndex > best.stepIndex) {
+            best = { fileAbsPath, stepIndex, capturedAtMs };
+        }
+    }
+    if (best === null) {
+        return null;
+    }
+    return {
+        fileAbsPath: best.fileAbsPath,
+        displayName: `Failure Screenshot: ${flowName} (attempt ${args.attemptIndex + 1})`,
+        metadata: {
+            kind: 'maestro-test-screenshot',
+            flowName,
+            attemptIndex: args.attemptIndex,
+            capturedAtMs: best.capturedAtMs,
+        },
+    };
+}
+// Maestro names a bundle dir `<cleanFlow>` optionally + `-shard-<n>` (sharded) + `-<n>` (name
+// collision), where cleanFlow is the flow name with '/' -> '_'. Those suffixes share a namespace
+// with legitimate flow names, so we can't strip blindly (a flow may be named `x-shard-1` or `x-2`).
+// Enumerate the ways the dir name could peel back to a flow name, keep those that match a failed
+// flow, and use the result only if exactly one fits — otherwise skip rather than guess.
+function resolveBundleFlowName(bundleName, normalizedFailedFlowNames) {
+    const withoutCollision = bundleName.replace(/-\d+$/, '');
+    const preimages = [
+        bundleName,
+        withoutCollision,
+        withoutCollision.replace(/-shard-\d+$/, ''),
+        bundleName.replace(/-shard-\d+$/, ''),
+    ];
+    const matches = new Set(preimages.filter(name => normalizedFailedFlowNames.has(name)));
+    return matches.size === 1 ? [...matches][0] : null;
+}
+// Keep one screenshot per flow name (attemptIndex is constant within a harvest call), preferring
+// the latest capture when two bundles resolve to the same flow.
+function dedupeBundleShotsByFlowName(shots) {
+    const byFlowName = new Map();
+    for (const shot of shots) {
+        const existing = byFlowName.get(shot.metadata.flowName);
+        if (existing === undefined || shot.metadata.capturedAtMs > existing.metadata.capturedAtMs) {
+            byFlowName.set(shot.metadata.flowName, shot);
         }
     }
-    return results;
+    return [...byFlowName.values()];
+}
+// pre-v2.7.0 (Maestro <= 2.6.x) reader: a flat `screenshot-...❌...png` file whose name carries the
+// flow name and capture epoch.
+function harvestLegacyFlatShot(args) {
+    const parsed = parseFailureScreenshotFilename(args.fileName);
+    // Re-check capture time per file — a dir's mtime can advance after this attempt began, so the dir
+    // gate alone would re-attribute an earlier attempt's screenshot to this one.
+    if (parsed === null || parsed.capturedAtMs < args.capturedSinceMs) {
+        return null;
+    }
+    return {
+        fileAbsPath: path_1.default.join(args.sessionDir, args.fileName),
+        displayName: `Failure Screenshot: ${parsed.flowName} (attempt ${args.attemptIndex + 1})`,
+        metadata: {
+            kind: 'maestro-test-screenshot',
+            flowName: parsed.flowName,
+            attemptIndex: args.attemptIndex,
+            capturedAtMs: parsed.capturedAtMs,
+        },
+    };
 }
 // Maestro substitutes '/' -> '_' in screenshot filenames (so HarvestedScreenshot.flowName
 // is already in that form) but keeps '/' in the JUnit testcase name. Normalize the JUnit

package/dist/steps/functions/maestroTests.js

@@ -216,10 +216,14 @@ function createMaestroTestsBuildFunction(ctx) {
                 // junit: test-case-result rows (and therefore the summary icons) only exist for junit
                 // runs, so harvesting other formats would just create orphan artifacts the website hides.
                 if (outputFormat === 'junit') {
+                    const failedFlowNames = outputPath
+                        ? await (0, maestroResultParser_1.parseFailedFlowNamesFromJUnitFile)(outputPath)
+                        : new Set();
                     harvested.push(...(await (0, maestroScreenshots_1.harvestFailureScreenshotsAsync)({
                         testsDirectory,
                         capturedSinceMs: attemptStartedAtMs,
                         attemptIndex: attempt,
+                        failedFlowNames,
                         logger,
                     })));
                 }

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -16,18 +16,17 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             logger.info('Starting serve-sim remote session.');
             await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
-            const { previewUrl, streamUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
+            const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                 baseDomain: ngrokTunnelDomain,
                 env,
                 logger,
                 timeoutMs: STARTUP_TIMEOUT_MS,
             });
             logger.info(`Preview URL: ${previewUrl}`);
-            logger.info(`Stream URL: ${streamUrl}`);
             await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
                 ctx,
                 deviceRunSessionId,
-                remoteConfig: { previewUrl, streamUrl },
+                remoteConfig: { previewUrl },
                 logger,
             });
             await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({

package/dist/steps/functions/uploadDeviceRunSessionScreenRecordings.js

@@ -25,8 +25,22 @@ const RecordingManifestSchema = zod_1.z.object({
     firstFrameWallClock: zod_1.z.object({
         iso8601: zod_1.z.string(),
     }),
+    width: zod_1.z.number().int().positive(),
+    height: zod_1.z.number().int().positive(),
     recording: zod_1.z.string(),
 });
+const recordingStartTimeFormatter = new Intl.DateTimeFormat('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    fractionalSecondDigits: 3,
+    hourCycle: 'h23',
+    timeZone: 'UTC',
+    timeZoneName: 'short',
+});
 function createUploadDeviceRunSessionScreenRecordingsBuildFunction(ctx) {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -56,9 +70,11 @@ function createUploadDeviceRunSessionScreenRecordingsBuildFunction(ctx) {
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const limit = (0, promise_limit_1.default)(5);
             await Promise.all(recordings.map(recording => limit(async () => {
-                const displayName = `${recording.deviceName} screen recording`;
                 try {
                     const metadata = RecordingManifestSchema.parse(JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(recording.directory, 'session.json'), 'utf-8')));
+                    const startedAt = recordingStartTimeFormatter.format(new Date(metadata.firstFrameWallClock.iso8601));
+                    const shortUdid = `${recording.udid.slice(0, 8)}-…`;
+                    const displayName = `${recording.deviceName} screen recording (${shortUdid}, started at ${startedAt})`;
                     const recordingPath = node_path_1.default.join(recording.directory, metadata.recording);
                     const { size } = await (0, promises_1.stat)(recordingPath);
                     const recordingId = node_path_1.default.basename(recording.directory);
@@ -70,11 +86,14 @@ function createUploadDeviceRunSessionScreenRecordingsBuildFunction(ctx) {
                         filename: `${recordingId}.mp4`,
                         kind: 'screen-recording',
                         metadata: {
+                            __eas_type: 'screen-recording',
                             __eas_screen_recording: '1',
                             udid: recording.udid,
                             deviceName: recording.deviceName,
                             runtimeDisplayName: recording.runtimeDisplayName,
                             firstFrameAt: metadata.firstFrameWallClock.iso8601,
+                            width: metadata.width,
+                            height: metadata.height,
                         },
                         size,
                         stream: (0, node_fs_1.createReadStream)(recordingPath),

package/dist/steps/utils/IosSimulatorRecordingUtils.js

@@ -13,7 +13,7 @@ const promises_2 = require("node:timers/promises");
 const sentry_1 = require("../../sentry");
 const IosSimulatorUtils_1 = require("../../utils/IosSimulatorUtils");
 const IOS_SIMULATOR_RECORDING_POLL_INTERVAL_MS = 2_000;
-const RECORD_SIM_FINISH_TIMEOUT_MS = 30_000;
+const RECORD_SIM_FINISH_TIMEOUT_MS = 70_000;
 const RECORD_SIM_FORCE_STOP_TIMEOUT_MS = 5_000;
 const RECORD_SIM_MAX_ATTEMPTS_PER_BOOT = 3;
 const RECORD_SIM_COMMAND = 'record-sim';
@@ -70,7 +70,11 @@ var IosSimulatorRecordingUtils;
             if (finished) {
                 return;
             }
-            logger.warn(`Forcing iOS Simulator recording process for ${recording.deviceName} to stop.`);
+            const recordSimOutput = recording.getOutput().trim();
+            const finishTimeoutSeconds = Math.round(RECORD_SIM_FINISH_TIMEOUT_MS / 1_000);
+            logger.warn({ recordSimOutput }, `Screen recording for ${recording.deviceName} did not finish within ${finishTimeoutSeconds} seconds and will be stopped.${recordSimOutput
+                ? `\nRecent recorder messages:\n${recordSimOutput}`
+                : '\nNo recorder messages were captured.'}`);
             recording.recordingProcess.kill('SIGKILL');
             const killed = await Promise.race([
                 recording.completionPromise.then(() => true),

package/dist/steps/utils/remoteDeviceRunSession.d.ts

@@ -65,7 +65,6 @@ export declare function startServeSimWithTunnelAsync(ctx: CustomBuildContext, {
     timeoutMs: number;
 }): Promise<{
     previewUrl: string;
-    streamUrl: string;
 }>;
 export declare function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authtoken, rewriteHostHeader, logger, }: {
     port: number;

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -289,21 +289,20 @@ async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, time
         ],
         env,
     });
-    logger.info('Waiting for serve-sim to report tunnel and stream URLs.');
+    logger.info('Waiting for serve-sim to report tunnel URL.');
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
         const output = serveSim.getOutput();
-        const previewUrl = matchLabeledUrl({ output, label: 'Tunnel', baseDomain });
-        const streamUrl = matchLabeledUrl({ output, label: 'Stream', baseDomain });
-        if (previewUrl && streamUrl) {
-            return { previewUrl, streamUrl };
+        const previewUrl = matchTunnelUrl({ output, baseDomain });
+        if (previewUrl) {
+            return { previewUrl };
         }
         await (0, retry_1.sleepAsync)(1_000);
     }
-    throw new eas_build_job_1.SystemError(`Timed out waiting for serve-sim to report Tunnel and Stream URLs. Last output:\n${serveSim.getOutput() || '<empty>'}`);
+    throw new eas_build_job_1.SystemError(`Timed out waiting for serve-sim to report Tunnel URL. Last output:\n${serveSim.getOutput() || '<empty>'}`);
 }
-function matchLabeledUrl({ output, label, baseDomain, }) {
-    const labelPattern = new RegExp(`${label}:\\s*(https:\\/\\/[a-z0-9-]+\\.${escapeRegExp(baseDomain)})`);
+function matchTunnelUrl({ output, baseDomain, }) {
+    const labelPattern = new RegExp(`Tunnel:\\s*(https:\\/\\/[a-z0-9-]+\\.${escapeRegExp(baseDomain)})`);
     const match = labelPattern.exec(output);
     return match ? match[1] : null;
 }

package/dist/{gcs → storage}/retry.d.ts

@@ -1,11 +1,12 @@
 import { Response } from 'node-fetch';
-export interface RetryOptions {
+type RetryOptions = {
     retries: number;
     retryIntervalMs: number;
-    shouldRetryOnError: (error: any) => boolean;
+    shouldRetryOnError: (error: unknown) => boolean;
     shouldRetryOnResponse: (response: Response) => boolean;
-}
-export declare function retryOnGCSUploadFailure(fn: (attemptCount: number) => Promise<Response>, { retries, retryIntervalMs, }: {
+};
+export declare function retryOnUploadFailure(fn: (attemptCount: number) => Promise<Response>, { retries, retryIntervalMs, }: {
     retries: RetryOptions['retries'];
     retryIntervalMs: RetryOptions['retryIntervalMs'];
 }): Promise<Response>;
+export {};

package/dist/{gcs → storage}/retry.js

@@ -1,25 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retryOnGCSUploadFailure = retryOnGCSUploadFailure;
+exports.retryOnUploadFailure = retryOnUploadFailure;
 // based on https://github.com/googleapis/nodejs-storage/blob/8ab50804fc7bae3bbd159bbb4adf65c02215b11b/src/storage.ts#L284-L320
-async function retryOnGCSUploadFailure(fn, { retries, retryIntervalMs, }) {
+async function retryOnUploadFailure(fn, { retries, retryIntervalMs, }) {
     return await retry(fn, {
         retries,
         retryIntervalMs,
-        shouldRetryOnError: e => {
-            return (e.code === 'ENOTFOUND' ||
-                e.code === 'EAI_AGAIN' ||
-                e.code === 'ECONNRESET' ||
-                e.code === 'ETIMEDOUT' ||
-                e.code === 'EPIPE');
+        shouldRetryOnError: err => {
+            return (isErrorWithCode(err) &&
+                (err.code === 'ENOTFOUND' ||
+                    err.code === 'EAI_AGAIN' ||
+                    err.code === 'ECONNRESET' ||
+                    err.code === 'ETIMEDOUT' ||
+                    err.code === 'EPIPE'));
         },
         shouldRetryOnResponse: resp => {
             return [408, 429, 500, 502, 503, 504].includes(resp.status);
         },
     });
 }
+function isErrorWithCode(error) {
+    return typeof error === 'object' && error !== null && 'code' in error;
+}
 /**
- * Wrapper used to execute an inner function and possibly retry it if it throws and error
+ * Wrapper used to execute an inner function and possibly retry it if it throws an error
  * @param fn Function to be executed and retried in case of error
  * @param retries How many times at most should the function be retried
  * @param retryIntervalMs Time interval between the retries

package/dist/storage/uploadWithSignedUrl.d.ts

@@ -0,0 +1,12 @@
+import { Readable } from 'stream';
+export type SignedUrl = {
+    url: string;
+    headers: Record<string, string>;
+};
+export type UploadWithSignedUrlParams = {
+    signedUrl: SignedUrl;
+    srcGeneratorAsync: () => Promise<Readable>;
+    retryIntervalMs?: number;
+    retries?: number;
+};
+export declare function uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries, retryIntervalMs, }: UploadWithSignedUrlParams): Promise<string>;

package/dist/storage/uploadWithSignedUrl.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadWithSignedUrl = uploadWithSignedUrl;
+const node_fetch_1 = __importStar(require("node-fetch"));
+const url_1 = require("url");
+const retry_1 = require("./retry");
+async function uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries = 2, retryIntervalMs = 30_000, }) {
+    let resp;
+    try {
+        resp = await (0, retry_1.retryOnUploadFailure)(async () => {
+            const src = await srcGeneratorAsync();
+            return await (0, node_fetch_1.default)(signedUrl.url, {
+                method: 'PUT',
+                headers: signedUrl.headers,
+                body: src,
+            });
+        }, { retries, retryIntervalMs });
+    }
+    catch (err) {
+        if (err instanceof node_fetch_1.FetchError) {
+            throw new Error(`Failed to upload the file, reason: ${err.code}`);
+        }
+        throw err;
+    }
+    if (!resp.ok) {
+        let body;
+        try {
+            body = await resp.text();
+        }
+        catch { }
+        throw new Error(`Failed to upload file: status: ${resp.status} status text: ${resp.statusText}, body: ${body}`);
+    }
+    const url = new url_1.URL(signedUrl.url);
+    return `${url.protocol}//${url.host}${url.pathname}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "21.0.1",
+  "version": "21.0.3",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -39,18 +39,17 @@
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
     "@expo/downloader": "21.0.0",
-    "@expo/eas-build-job": "21.0.1",
+    "@expo/eas-build-job": "21.0.3",
     "@expo/env": "^0.4.0",
     "@expo/logger": "21.0.0",
     "@expo/package-manager": "1.9.10",
-    "@expo/plist": "^0.2.0",
+    "@expo/plist": "^0.3.5",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "21.0.1",
-    "@expo/template-file": "21.0.0",
+    "@expo/steps": "21.0.3",
+    "@expo/template-file": "21.0.2",
     "@expo/turtle-spawn": "21.0.0",
     "@expo/xcpretty": "^4.3.1",
-    "@google-cloud/storage": "^7.11.2",
     "@ngrok/ngrok": "1.7.0",
     "@sentry/node": "7.77.0",
     "@urql/core": "^6.0.1",
@@ -61,7 +60,7 @@
     "gql.tada": "^1.8.13",
     "joi": "^17.13.1",
     "jose": "5.10.0",
-    "lodash": "^4.17.21",
+    "lodash": "^4.18.1",
     "node-fetch": "^2.7.0",
     "node-forge": "^1.3.1",
     "node-stream-zip": "1.15.0",
@@ -101,5 +100,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "a62289b9888b71fe90e3022840643b182b732048"
+  "gitHead": "62d46fece55ab5b27c2a572fc91158214b9ae96b"
 }

package/resources/record-sim/Sources/RecordSim/RecordingModels.swift

@@ -59,8 +59,15 @@ public struct FirstFrameWallClock: Codable, Sendable {
     public let iso8601: String
 }
 
+public enum RecordingFinalizationStage: Sendable {
+    case captureStopped
+    case videoSaved
+}
+
 public struct RecordingManifest: Codable, Sendable {
     public let firstFrameWallClock: FirstFrameWallClock
+    public let width: Int
+    public let height: Int
     public let hlsVersion: Int?
     public let hlsTargetDurationSeconds: Int?
     public let hlsMediaSequence: Int?

package/resources/record-sim/Sources/RecordSim/RecordingOutputWriter.swift

@@ -100,7 +100,9 @@ final class RecordingOutputWriter: NSObject, AVAssetWriterDelegate {
     @discardableResult
     func writeManifest(
         configuration: SimulatorRecordingConfiguration,
-        firstFrameWallClock: Date
+        firstFrameWallClock: Date,
+        width: Int,
+        height: Int
     ) throws -> RecordingManifest {
         try stateQueue.sync {
             if let firstError {
@@ -121,6 +123,8 @@ final class RecordingOutputWriter: NSObject, AVAssetWriterDelegate {
                     unixMs: unixMs(firstFrameWallClock),
                     iso8601: iso8601(firstFrameWallClock)
                 ),
+                width: width,
+                height: height,
                 hlsVersion: segmented ? 7 : nil,
                 hlsTargetDurationSeconds: targetDuration,
                 hlsMediaSequence: segmented ? 0 : nil,