@expo/build-tools 21.0.2 → 21.0.3

package/dist/builders/android.js

@@ -41,7 +41,18 @@ async function androidBuilder(ctx) {
     }
 }
 async function buildAsync(ctx) {
-    await (0, setup_1.setupAsync)(ctx);
+    const jobHooksRef = { current: null };
+    try {
+        await buildInnerAsync(ctx, jobHooksRef);
+    }
+    finally {
+        // Native builds have no other drain path for the hook context's queued
+        // step-metric uploads.
+        await jobHooksRef.current?.customBuildContext.drainPendingMetricUploads();
+    }
+}
+async function buildInnerAsync(ctx, jobHooksRef) {
+    await (0, setup_1.setupAsync)(ctx, { wrappedAnchors: ['install_node_modules'], jobHooksRef });
     const evictUsedBefore = new Date();
     const workingDirectory = ctx.getReactNativeProjectDirectory();
     const hasNativeCode = ctx.job.type === eas_build_job_1.Workflow.GENERIC;

package/dist/builders/ios.js

@@ -50,7 +50,19 @@ async function iosBuilder(ctx) {
     }
 }
 async function buildAsync(ctx) {
-    await (0, setup_1.setupAsync)(ctx);
+    const jobHooksRef = { current: null };
+    try {
+        await buildInnerAsync(ctx, jobHooksRef);
+    }
+    finally {
+        // Native builds have no other drain path for the hook context's queued
+        // step-metric uploads. Must wrap the WHOLE body — iOS's existing inner
+        // try/finally only starts after setupAsync returns.
+        await jobHooksRef.current?.customBuildContext.drainPendingMetricUploads();
+    }
+}
+async function buildInnerAsync(ctx, jobHooksRef) {
+    await (0, setup_1.setupAsync)(ctx, { wrappedAnchors: ['install_node_modules'], jobHooksRef });
     const hasNativeCode = ctx.job.type === eas_build_job_1.Workflow.GENERIC;
     const evictUsedBefore = new Date();
     const credentialsManager = new manager_1.default(ctx);

package/dist/common/easBuildInternal.js

@@ -111,6 +111,9 @@ function validateEasBuildInternalResult({ oldJob, result, }) {
         // We want to retain values that we have set on the job.
         appId: oldJob.appId,
         initiatingUserId: oldJob.initiatingUserId,
+        // Hooks are resolved server-side at submit; the mid-build eas.json
+        // regeneration must not add, drop, or change them (the original wins).
+        hooks: oldJob.hooks,
         ...(oldJob.platform === eas_build_job_1.Platform.IOS && oldJob.refreshAdHocProvisioningProfile === true
             ? { refreshAdHocProvisioningProfile: true }
             : null),

package/dist/common/hookableBuildPhase.d.ts

@@ -0,0 +1,18 @@
+import { BuildJob, BuildPhase, HookAnchorId } from '@expo/eas-build-job';
+import { BuildContext } from '../context';
+import { ParsedJobHooks } from './jobHooks';
+/**
+ * Runs a native build phase with its `before_<anchor>` / `after_<anchor>` hooks
+ * wrapped around it: before-entries -> phase (in a try) -> after-entries, with
+ * after-on-failure guaranteed. A failing before sequence skips the phase AND the
+ * after-hooks (steps-engine parity). The phase error always wins over an
+ * after-hook error. Passthrough (no hooks or no keys for this anchor) runs the
+ * phase exactly once with zero overhead.
+ */
+export declare function runHookableBuildPhaseAsync<TJob extends BuildJob, T>({ ctx, hooks, buildPhase, anchor, fn, }: {
+    ctx: BuildContext<TJob>;
+    hooks: ParsedJobHooks | null;
+    buildPhase: BuildPhase;
+    anchor: HookAnchorId;
+    fn: () => Promise<T>;
+}): Promise<T>;

package/dist/common/hookableBuildPhase.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHookableBuildPhaseAsync = runHookableBuildPhaseAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+/**
+ * Runs a native build phase with its `before_<anchor>` / `after_<anchor>` hooks
+ * wrapped around it: before-entries -> phase (in a try) -> after-entries, with
+ * after-on-failure guaranteed. A failing before sequence skips the phase AND the
+ * after-hooks (steps-engine parity). The phase error always wins over an
+ * after-hook error. Passthrough (no hooks or no keys for this anchor) runs the
+ * phase exactly once with zero overhead.
+ */
+async function runHookableBuildPhaseAsync({ ctx, hooks, buildPhase, anchor, fn, }) {
+    // runHookEntriesAsync no-ops when the key has no entries.
+    if (hooks) {
+        await runHookEntriesAsync({ ctx, hooks, timing: 'before', anchor });
+    }
+    let result;
+    try {
+        result = await ctx.runBuildPhase(buildPhase, fn);
+    }
+    catch (phaseError) {
+        if (hooks) {
+            try {
+                await runHookEntriesAsync({ ctx, hooks, timing: 'after', anchor, anchorFailed: true });
+            }
+            catch (hookError) {
+                // The phase error wins; still surface the after-hook failure in the log.
+                ctx.logger.error({ err: hookError }, `after_${anchor} hook failed`);
+            }
+        }
+        throw phaseError;
+    }
+    if (hooks) {
+        await runHookEntriesAsync({ ctx, hooks, timing: 'after', anchor, anchorFailed: false });
+    }
+    return result;
+}
+async function runHookEntriesAsync({ ctx, hooks, timing, anchor, anchorFailed = false, }) {
+    const hookKey = `${timing}_${anchor}`;
+    const entries = hooks.hookEntriesByKey[hookKey];
+    if (!entries?.length) {
+        return;
+    }
+    // Refresh the hook context from the live BuildContext before running: env
+    // moves as the build runs (set-env written back below; profile env), and
+    // job/metadata are replaced by eas build:internal.
+    hooks.customBuildContext.updateEnv(ctx.env);
+    // Overwrite the job/metadata snapshot; NOT updateJobInformation, whose
+    // delta-merge would duplicate environmentSecrets on each refresh.
+    hooks.customBuildContext.job = ctx.job;
+    hooks.customBuildContext.metadata = ctx.metadata;
+    if (timing === 'after' && anchorFailed) {
+        // Mirror the engine: the anchor's failure is marked on the shared context so
+        // `failure()` / `success()` on after-hook steps read the phase outcome.
+        hooks.globalContext.markAsFailed();
+    }
+    const { failedLocally, firstError } = await (0, steps_1.executeHookStepsAsync)(hooks.globalContext, entries, {
+        anchor,
+        timing,
+        ...(timing === 'after' ? { anchorResult: anchorFailed ? 'failed' : 'success' } : null),
+    });
+    // Reverse write-back BEFORE propagating a failure: env set by the entries that
+    // did run must reach the build context even when a later entry failed, so the
+    // native phases (and the outer lifecycle hooks) see it. Hook-carrying builds
+    // are git-based, so updateEnv's gate does not fire here.
+    ctx.updateEnv(hooks.globalContext.env);
+    if (failedLocally) {
+        throw new eas_build_job_1.UserError(eas_build_job_1.ErrorCode.HOOKS_ERROR, `Hook "${hookKey}" failed: ${firstError instanceof Error ? firstError.message : String(firstError)}. Check the failing hook step's logs above.`, { cause: firstError });
+    }
+}

package/dist/common/jobHooks.d.ts

@@ -0,0 +1,16 @@
+import { BuildJob, HookAnchorId, HookKey } from '@expo/eas-build-job';
+import { BuildStepGlobalContext, HookEntry } from '@expo/steps';
+import { BuildContext } from '../context';
+import { CustomBuildContext } from '../customBuildContext';
+export interface ParsedJobHooks {
+    globalContext: BuildStepGlobalContext;
+    customBuildContext: CustomBuildContext;
+    hookEntriesByKey: Partial<Record<HookKey, HookEntry[]>>;
+}
+/**
+ * Parses the native job's `hooks` into engine-ready entries, once, at setup
+ * time. Shape-validates every registered key (reachable or not); constructs
+ * entries only for the anchors this build actually wraps. Returns null when the
+ * job declares no hooks.
+ */
+export declare function parseJobHooksAsync<TJob extends BuildJob>(ctx: BuildContext<TJob>, wrappedAnchors: readonly HookAnchorId[]): Promise<ParsedJobHooks | null>;

package/dist/common/jobHooks.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJobHooksAsync = parseJobHooksAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const customBuildContext_1 = require("../customBuildContext");
+const easFunctionGroups_1 = require("../steps/easFunctionGroups");
+const easFunctions_1 = require("../steps/easFunctions");
+/**
+ * Parses the native job's `hooks` into engine-ready entries, once, at setup
+ * time. Shape-validates every registered key (reachable or not); constructs
+ * entries only for the anchors this build actually wraps. Returns null when the
+ * job declares no hooks.
+ */
+async function parseJobHooksAsync(ctx, wrappedAnchors) {
+    const hooks = ctx.job.hooks;
+    if (!hooks || Object.keys(hooks).length === 0) {
+        return null;
+    }
+    const customBuildContext = new customBuildContext_1.CustomBuildContext(ctx);
+    const globalContext = new steps_1.BuildStepGlobalContext(customBuildContext, false);
+    // Hook steps run in the checked-out project directory, not the pre-checkout
+    // target directory the global context defaults to.
+    globalContext.markAsCheckedOut(ctx.logger);
+    const externalFunctions = (0, easFunctions_1.getEasFunctions)(customBuildContext);
+    const externalFunctionGroups = (0, easFunctionGroups_1.getEasFunctionGroups)(customBuildContext);
+    // Shape-validate every REGISTERED key, reachable or not (steps-world parity:
+    // a malformed `before_submit` fails a steps build, so it fails here too), and
+    // warn on keys this build won't run. An unknown key is inert — a key newer
+    // than this worker must be ignored, never fail the job.
+    for (const [key, steps] of Object.entries(hooks)) {
+        const parsed = (0, eas_build_job_1.parseHookKey)(key);
+        if (parsed === null) {
+            ctx.logger.warn(`Ignoring unknown hook key "${key}".`);
+            continue;
+        }
+        if (Array.isArray(steps) && steps.length === 0) {
+            // `[]` is an explicit opt-out; validateSteps requires >= 1 step.
+            continue;
+        }
+        try {
+            (0, eas_build_job_1.validateSteps)(steps);
+        }
+        catch (err) {
+            throw new eas_build_job_1.UserError(eas_build_job_1.ErrorCode.HOOKS_ERROR, `Invalid steps in "hooks.${key}": ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        // Registered but not wrapped by this build: shape-checked above, then
+        // skipped. Function existence is deliberately NOT checked (that happens only
+        // during construction) — an unknown `uses:` under an unwrapped key warns
+        // rather than failing the build.
+        if (!wrappedAnchors.includes(parsed.anchorId)) {
+            ctx.logger.warn(`Ignoring "hooks.${key}": this build does not run the "${parsed.anchorId}" step.`);
+        }
+    }
+    // Construct entries for the wrapped anchors in EXECUTION order (per anchor,
+    // before_ then after_) so generated step ids and output references follow the
+    // order steps actually run. All entries share one globalContext, so env and
+    // outputs accumulate across keys.
+    const hookEntriesByKey = {};
+    const orderedSteps = [];
+    for (const anchor of wrappedAnchors) {
+        for (const side of ['before', 'after']) {
+            const key = `${side}_${anchor}`;
+            const steps = hooks[key];
+            if (!Array.isArray(steps) || steps.length === 0) {
+                continue;
+            }
+            let entries;
+            try {
+                entries = await (0, steps_1.constructHookEntriesAsync)(globalContext, steps, {
+                    externalFunctions,
+                    externalFunctionGroups,
+                });
+            }
+            catch (err) {
+                throw new eas_build_job_1.UserError(eas_build_job_1.ErrorCode.HOOKS_ERROR, `Failed to parse hooks.${key}: ${err instanceof Error ? err.message : String(err)}. Hooks use the same syntax as workflow steps.`, { cause: err });
+            }
+            hookEntriesByKey[key] = entries;
+            for (const entry of entries) {
+                orderedSteps.push(...entry.steps);
+            }
+        }
+    }
+    // One aggregate pass over every constructed step in execution order: unique
+    // ids, output references, and platform allowance. Per-key validation misses
+    // cross-key id collisions and would reject a legal after -> before output
+    // reference as a future reference.
+    try {
+        await (0, steps_1.validateHookStepsAsync)(globalContext, orderedSteps);
+    }
+    catch (err) {
+        throw new eas_build_job_1.UserError(eas_build_job_1.ErrorCode.HOOKS_ERROR, `The job's hooks are invalid: ${err instanceof Error ? err.message : String(err)}. Fix the reported step ids or output references.`, { cause: err });
+    }
+    return { globalContext, customBuildContext, hookEntriesByKey };
+}

package/dist/common/setup.d.ts

@@ -1,3 +1,15 @@
-import { BuildJob } from '@expo/eas-build-job';
+import { BuildJob, HookAnchorId } from '@expo/eas-build-job';
+import { ParsedJobHooks } from './jobHooks';
 import { BuildContext } from '../context';
-export declare function setupAsync<TJob extends BuildJob>(ctx: BuildContext<TJob>): Promise<void>;
+/**
+ * Mutable holder the builder passes into setupAsync. setupAsync assigns
+ * `current` the moment hooks are parsed (before any hook runs), so the builder's
+ * finally can drain queued metric uploads even if setup fails partway through.
+ */
+export interface JobHooksRef {
+    current: ParsedJobHooks | null;
+}
+export declare function setupAsync<TJob extends BuildJob>(ctx: BuildContext<TJob>, { wrappedAnchors, jobHooksRef, }: {
+    wrappedAnchors: readonly HookAnchorId[];
+    jobHooksRef: JobHooksRef;
+}): Promise<void>;

package/dist/common/setup.js

@@ -10,7 +10,9 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
 const path_1 = __importDefault(require("path"));
 const easBuildInternal_1 = require("./easBuildInternal");
+const hookableBuildPhase_1 = require("./hookableBuildPhase");
 const installDependencies_1 = require("./installDependencies");
+const jobHooks_1 = require("./jobHooks");
 const projectSources_1 = require("./projectSources");
 const xcodeEnv_1 = require("../ios/xcodeEnv");
 const hooks_1 = require("../utils/hooks");
@@ -26,7 +28,7 @@ class DoctorTimeoutError extends Error {
 }
 class InstallDependenciesTimeoutError extends Error {
 }
-async function setupAsync(ctx) {
+async function setupAsync(ctx, { wrappedAnchors, jobHooksRef, }) {
     await ctx.runBuildPhase(eas_build_job_1.BuildPhase.PREPARE_PROJECT, async () => {
         await (0, retry_1.retryAsync)(async () => {
             await fs_extra_1.default.rm(ctx.buildDirectory, { recursive: true, force: true });
@@ -64,27 +66,42 @@ async function setupAsync(ctx) {
             ctx.logger.error({ err }, `Failed to read eas.json.`);
         }
     });
-    const packageJson = await ctx.runBuildPhase(eas_build_job_1.BuildPhase.READ_PACKAGE_JSON, async () => {
-        return (0, project_1.readAndLogPackageJson)(ctx.logger, ctx.getReactNativeProjectDirectory());
+    await ctx.runBuildPhase(eas_build_job_1.BuildPhase.READ_PACKAGE_JSON, async () => {
+        (0, project_1.readAndLogPackageJson)(ctx.logger, ctx.getReactNativeProjectDirectory());
     });
-    await ctx.runBuildPhase(eas_build_job_1.BuildPhase.INSTALL_DEPENDENCIES, async () => {
-        const expoVersion = ctx.metadata?.sdkVersion ??
-            (0, packageManager_1.getPackageVersionFromPackageJson)({
-                packageJson,
-                packageName: 'expo',
+    // Parse hooks unconditionally, after every pre-install env mutation
+    // (PREPARE_PROJECT, the git-based profile-env block, PRE_INSTALL_HOOK) and
+    // before the first wrapped phase.
+    jobHooksRef.current = await (0, jobHooks_1.parseJobHooksAsync)(ctx, wrappedAnchors);
+    await (0, hookableBuildPhase_1.runHookableBuildPhaseAsync)({
+        ctx,
+        hooks: jobHooksRef.current,
+        buildPhase: eas_build_job_1.BuildPhase.INSTALL_DEPENDENCIES,
+        anchor: 'install_node_modules',
+        fn: async () => {
+            // Read package.json fresh here rather than reusing the READ_PACKAGE_JSON
+            // capture: a before_install_node_modules hook may have patched it, and the
+            // steps-world install already reads it fresh. Silent read — READ_PACKAGE_JSON
+            // stays the only logging site.
+            const freshPackageJson = (0, project_1.readPackageJson)(ctx.getReactNativeProjectDirectory());
+            const expoVersion = ctx.metadata?.sdkVersion ??
+                (0, packageManager_1.getPackageVersionFromPackageJson)({
+                    packageJson: freshPackageJson,
+                    packageName: 'expo',
+                });
+            const reactNativeVersion = ctx.metadata?.reactNativeVersion ??
+                (0, packageManager_1.getPackageVersionFromPackageJson)({
+                    packageJson: freshPackageJson,
+                    packageName: 'react-native',
+                });
+            await runInstallDependenciesAsync(ctx, {
+                useFrozenLockfile: (0, packageManager_1.shouldUseFrozenLockfile)({
+                    env: ctx.env,
+                    sdkVersion: expoVersion,
+                    reactNativeVersion,
+                }),
             });
-        const reactNativeVersion = ctx.metadata?.reactNativeVersion ??
-            (0, packageManager_1.getPackageVersionFromPackageJson)({
-                packageJson,
-                packageName: 'react-native',
-            });
-        await runInstallDependenciesAsync(ctx, {
-            useFrozenLockfile: (0, packageManager_1.shouldUseFrozenLockfile)({
-                env: ctx.env,
-                sdkVersion: expoVersion,
-                reactNativeVersion,
-            }),
-        });
+        },
     });
     await ctx.runBuildPhase(eas_build_job_1.BuildPhase.READ_APP_CONFIG, async () => {
         const appConfig = await ctx.appConfig;
@@ -111,7 +128,9 @@ async function setupAsync(ctx) {
             ctx.updateJobInformation(newJob, newMetadata);
         });
     }
-    const hasExpoPackage = !!packageJson.dependencies?.expo;
+    // Read fresh: a before_install_node_modules hook may have added or removed
+    // the expo dependency.
+    const hasExpoPackage = !!(0, project_1.readPackageJson)(ctx.getReactNativeProjectDirectory()).dependencies?.expo;
     if (!ctx.env.EAS_BUILD_DISABLE_EXPO_DOCTOR_STEP && hasExpoPackage) {
         await ctx.runBuildPhase(eas_build_job_1.BuildPhase.RUN_EXPO_DOCTOR, async () => {
             try {

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as Builders from './builders';
-import GCSLoggerStream from './gcs/LoggerStream';
-import { GCS } from './gcs/client';
-export { Builders, GCS, GCSLoggerStream };
+import RemoteLoggerStream from './logging/RemoteLoggerStream';
+export { Builders, RemoteLoggerStream };
+export { uploadWithSignedUrl } from './storage/uploadWithSignedUrl';
+export type { SignedUrl, UploadWithSignedUrlParams } from './storage/uploadWithSignedUrl';
 export { ArtifactToUpload, Artifacts, BuildContext, BuildContextOptions, CacheManager, LogBuffer, SkipNativeBuildError, } from './context';
 export { PackageManager } from './utils/packageManager';
 export { findAndUploadXcodeBuildLogsAsync } from './ios/xcodeBuildLogs';

package/dist/index.js

@@ -39,13 +39,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sentry = exports.Datadog = exports.formatGradleProfileReport = exports.parseGradleProfile = exports.runHookIfPresent = exports.Hook = exports.findAndUploadXcodeBuildLogsAsync = exports.PackageManager = exports.SkipNativeBuildError = exports.BuildContext = exports.GCSLoggerStream = exports.GCS = exports.Builders = void 0;
+exports.Sentry = exports.Datadog = exports.formatGradleProfileReport = exports.parseGradleProfile = exports.runHookIfPresent = exports.Hook = exports.findAndUploadXcodeBuildLogsAsync = exports.PackageManager = exports.SkipNativeBuildError = exports.BuildContext = exports.uploadWithSignedUrl = exports.RemoteLoggerStream = exports.Builders = void 0;
 const Builders = __importStar(require("./builders"));
 exports.Builders = Builders;
-const LoggerStream_1 = __importDefault(require("./gcs/LoggerStream"));
-exports.GCSLoggerStream = LoggerStream_1.default;
-const client_1 = require("./gcs/client");
-Object.defineProperty(exports, "GCS", { enumerable: true, get: function () { return client_1.GCS; } });
+const RemoteLoggerStream_1 = __importDefault(require("./logging/RemoteLoggerStream"));
+exports.RemoteLoggerStream = RemoteLoggerStream_1.default;
+var uploadWithSignedUrl_1 = require("./storage/uploadWithSignedUrl");
+Object.defineProperty(exports, "uploadWithSignedUrl", { enumerable: true, get: function () { return uploadWithSignedUrl_1.uploadWithSignedUrl; } });
 var context_1 = require("./context");
 Object.defineProperty(exports, "BuildContext", { enumerable: true, get: function () { return context_1.BuildContext; } });
 Object.defineProperty(exports, "SkipNativeBuildError", { enumerable: true, get: function () { return context_1.SkipNativeBuildError; } });

package/dist/{gcs/LoggerStream.d.ts → logging/RemoteLoggerStream.d.ts}

@@ -1,7 +1,7 @@
 import { bunyan } from '@expo/logger';
 import { Writable } from 'stream';
-import { GCS } from './client';
-declare class GCSLoggerStream extends Writable {
+import { type SignedUrl } from '../storage/uploadWithSignedUrl';
+declare class RemoteLoggerStream extends Writable {
     writable: boolean;
     private readonly logger;
     private readonly uploadMethod?;
@@ -16,7 +16,7 @@ declare class GCSLoggerStream extends Writable {
     private buffer;
     private writePromise?;
     private cleanUpCalled;
-    constructor({ logger, uploadMethod, options }: GCSLoggerStream.Config);
+    constructor({ logger, uploadMethod, options }: RemoteLoggerStream.Config);
     private findNormalizedHeader;
     init(): Promise<string>;
     cleanUp(): Promise<void>;
@@ -27,7 +27,7 @@ declare class GCSLoggerStream extends Writable {
     private upload;
     private createCompressedStream;
 }
-declare namespace GCSLoggerStream {
+declare namespace RemoteLoggerStream {
     enum CompressionMethod {
         GZIP = "gzip",
         BR = "br"
@@ -37,7 +37,7 @@ declare namespace GCSLoggerStream {
         compress?: CompressionMethod;
     }
     type UploadMethod = {
-        signedUrl: GCS.SignedUrl;
+        signedUrl: SignedUrl;
     };
     interface Config {
         logger: bunyan;
@@ -45,4 +45,4 @@ declare namespace GCSLoggerStream {
         options: Options;
     }
 }
-export default GCSLoggerStream;
+export default RemoteLoggerStream;

package/dist/{gcs/LoggerStream.js → logging/RemoteLoggerStream.js}

@@ -11,9 +11,9 @@ const path_1 = __importDefault(require("path"));
 const stream_1 = require("stream");
 const util_1 = require("util");
 const zlib_1 = __importDefault(require("zlib"));
-const client_1 = require("./client");
+const uploadWithSignedUrl_1 = require("../storage/uploadWithSignedUrl");
 const pipe = (0, util_1.promisify)(stream_1.pipeline);
-class GCSLoggerStream extends stream_1.Writable {
+class RemoteLoggerStream extends stream_1.Writable {
     writable = true;
     logger;
     uploadMethod;
@@ -74,7 +74,7 @@ class GCSLoggerStream extends stream_1.Writable {
         await this.flush(true);
         await fs_extra_1.default.remove(this.temporaryLogsPath);
         await fs_extra_1.default.remove(this.temporaryCompressedLogsPath);
-        this.logger.info('Cleaning up GCS log stream');
+        this.logger.info('Cleaning up log stream');
     }
     write(rec) {
         if (!this.fileHandle) {
@@ -102,7 +102,7 @@ class GCSLoggerStream extends stream_1.Writable {
             this.hasChangesToUpload = true;
         }
         catch (err) {
-            this.logger.error({ err, origin: 'gcs-logger' }, 'Failed to write logs to file');
+            this.logger.error({ err, origin: 'remote-logger' }, 'Failed to write logs to file');
         }
         finally {
             this.writePromise = undefined;
@@ -129,7 +129,7 @@ class GCSLoggerStream extends stream_1.Writable {
             return result;
         })
             .catch(err => {
-            this.logger.error({ err }, 'Failed to upload logs file to GCS');
+            this.logger.error({ err }, 'Failed to upload logs file');
         })
             .then(result => {
             this.uploadingPromise = undefined;
@@ -145,7 +145,7 @@ class GCSLoggerStream extends stream_1.Writable {
         const srcGeneratorAsync = async () => {
             return await this.createCompressedStream(fs_extra_1.default.createReadStream(this.temporaryLogsPath, { end: size }));
         };
-        return await client_1.GCS.uploadWithSignedUrl({
+        return await (0, uploadWithSignedUrl_1.uploadWithSignedUrl)({
             signedUrl: this.uploadMethod.signedUrl,
             srcGeneratorAsync,
         });
@@ -170,11 +170,11 @@ class GCSLoggerStream extends stream_1.Writable {
         return fs_extra_1.default.createReadStream(this.temporaryCompressedLogsPath, { end: size });
     }
 }
-(function (GCSLoggerStream) {
+(function (RemoteLoggerStream) {
     let CompressionMethod;
     (function (CompressionMethod) {
         CompressionMethod["GZIP"] = "gzip";
         CompressionMethod["BR"] = "br";
-    })(CompressionMethod = GCSLoggerStream.CompressionMethod || (GCSLoggerStream.CompressionMethod = {}));
-})(GCSLoggerStream || (GCSLoggerStream = {}));
-exports.default = GCSLoggerStream;
+    })(CompressionMethod = RemoteLoggerStream.CompressionMethod || (RemoteLoggerStream.CompressionMethod = {}));
+})(RemoteLoggerStream || (RemoteLoggerStream = {}));
+exports.default = RemoteLoggerStream;

package/dist/steps/functions/maestroResultParser.d.ts

@@ -17,6 +17,7 @@ export interface JUnitTestCaseResult {
     tags: string[];
     properties: Record<string, string>;
 }
+export declare function parseFailedFlowNamesFromJUnitFile(junitFile: string): Promise<Set<string>>;
 export declare function parseJUnitTestCases(junitDirectory: string): Promise<JUnitTestCaseResult[]>;
 export declare function isFileAttrRun(testcases: JUnitTestCaseResult[]): testcases is (JUnitTestCaseResult & {
     file: string;

package/dist/steps/functions/maestroResultParser.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFailedFlowNamesFromJUnitFile = parseFailedFlowNamesFromJUnitFile;
 exports.parseJUnitTestCases = parseJUnitTestCases;
 exports.isFileAttrRun = isFileAttrRun;
 exports.junitFileHasFileAttrs = junitFileHasFileAttrs;
@@ -99,6 +100,17 @@ async function parseJUnitFile(filePath) {
         return [];
     }
 }
+// Raw names (slashes kept) of the testcases a single JUnit file marks failed. Best-effort: an
+// unreadable or malformed file yields an empty set rather than throwing.
+async function parseFailedFlowNamesFromJUnitFile(junitFile) {
+    const failed = new Set();
+    for (const testcase of await parseJUnitFile(junitFile)) {
+        if (testcase.status === 'failed') {
+            failed.add(testcase.name);
+        }
+    }
+    return failed;
+}
 async function parseJUnitTestCases(junitDirectory) {
     let entries;
     try {

package/dist/steps/functions/maestroScreenshots.d.ts

@@ -18,6 +18,7 @@ export declare function harvestFailureScreenshotsAsync(args: {
     testsDirectory: string;
     capturedSinceMs: number;
     attemptIndex: number;
+    failedFlowNames: ReadonlySet<string>;
     logger: bunyan;
 }): Promise<HarvestedScreenshot[]>;
 export declare function computePureFailureFlowNames(testCases: readonly {

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/{gcs → storage}/retry.d.ts

@@ -5,7 +5,7 @@ type RetryOptions = {
     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>;

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

@@ -1,8 +1,8 @@
 "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,

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/{gcs/client.js → storage/uploadWithSignedUrl.js}

@@ -33,40 +33,36 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GCS = void 0;
+exports.uploadWithSignedUrl = uploadWithSignedUrl;
 const node_fetch_1 = __importStar(require("node-fetch"));
 const url_1 = require("url");
 const retry_1 = require("./retry");
-var GCS;
-(function (GCS) {
-    async function uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries = 2, retryIntervalMs = 30_000, }) {
-        let resp;
-        try {
-            resp = await (0, retry_1.retryOnGCSUploadFailure)(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;
+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}`);
         }
-        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}`);
+        throw err;
+    }
+    if (!resp.ok) {
+        let body;
+        try {
+            body = await resp.text();
         }
-        const url = new url_1.URL(signedUrl.url);
-        return `${url.protocol}//${url.host}${url.pathname}`;
+        catch { }
+        throw new Error(`Failed to upload file: status: ${resp.status} status text: ${resp.statusText}, body: ${body}`);
     }
-    GCS.uploadWithSignedUrl = uploadWithSignedUrl;
-})(GCS || (exports.GCS = GCS = {}));
+    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.2",
+  "version": "21.0.3",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -39,14 +39,14 @@
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
     "@expo/downloader": "21.0.0",
-    "@expo/eas-build-job": "21.0.2",
+    "@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.3.5",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "21.0.2",
+    "@expo/steps": "21.0.3",
     "@expo/template-file": "21.0.2",
     "@expo/turtle-spawn": "21.0.0",
     "@expo/xcpretty": "^4.3.1",
@@ -100,5 +100,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "e9ebc41413ae2b5c7b4b92e91f45e9f65e3dbd23"
+  "gitHead": "62d46fece55ab5b27c2a572fc91158214b9ae96b"
 }

package/dist/gcs/client.d.ts

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