@expo/build-tools 18.1.0 → 18.4.0

package/dist/ios/credentials/provisioningProfile.js

@@ -35,6 +35,7 @@ class ProvisioningProfile {
     }
     profilePath;
     profileData;
+    developerCertificates = [];
     constructor(ctx, profile, keychainPath, target, certificateCommonName) {
         this.ctx = ctx;
         this.profile = profile;
@@ -60,10 +61,11 @@ class ProvisioningProfile {
         await fs_extra_1.default.remove(this.profilePath);
     }
     verifyCertificate(fingerprint) {
-        const devCertFingerprint = this.genDerCertFingerprint();
-        if (devCertFingerprint !== fingerprint) {
-            throw new eas_build_job_1.errors.CredentialsDistCertMismatchError(`Provisioning profile and distribution certificate don't match.
-Profile's certificate fingerprint = ${devCertFingerprint}, distribution certificate fingerprint = ${fingerprint}`);
+        const devCertFingerprints = this.getAllDerCertFingerprints();
+        if (!devCertFingerprints.includes(fingerprint)) {
+            throw new eas_build_job_1.errors.CredentialsDistCertMismatchError(`Provisioning profile and distribution certificate don't match.\n` +
+                `Profile's certificate fingerprints = [${devCertFingerprints.join(', ')}], ` +
+                `distribution certificate fingerprint = ${fingerprint}`);
         }
     }
     async load() {
@@ -87,6 +89,7 @@ Profile's certificate fingerprint = ${devCertFingerprint}, distribution certific
         }
         const applicationIdentifier = plistData.Entitlements['application-identifier'];
         const bundleIdentifier = applicationIdentifier.replace(/^.+?\./, '');
+        this.developerCertificates = plistData.DeveloperCertificates.map((cert) => Buffer.from(cert, 'base64'));
         this.profileData = {
             path: this.profilePath,
             target: this.target,
@@ -94,7 +97,7 @@ Profile's certificate fingerprint = ${devCertFingerprint}, distribution certific
             teamId: plistData.TeamIdentifier[0],
             uuid: plistData.UUID,
             name: plistData.Name,
-            developerCertificate: Buffer.from(plistData.DeveloperCertificates[0], 'base64'),
+            developerCertificate: this.developerCertificates[0],
             certificateCommonName: this.certificateCommonName,
             distributionType: this.resolveDistributionType(plistData),
         };
@@ -110,12 +113,8 @@ Profile's certificate fingerprint = ${devCertFingerprint}, distribution certific
             return DistributionType.APP_STORE;
         }
     }
-    genDerCertFingerprint() {
-        return crypto_1.default
-            .createHash('sha1')
-            .update(new Uint8Array(this.data.developerCertificate))
-            .digest('hex')
-            .toUpperCase();
+    getAllDerCertFingerprints() {
+        return this.developerCertificates.map(cert => crypto_1.default.createHash('sha1').update(new Uint8Array(cert)).digest('hex').toUpperCase());
     }
 }
 exports.default = ProvisioningProfile;

package/dist/steps/functions/downloadArtifact.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDownloadArtifactFunction = createDownloadArtifactFunction;
 exports.downloadArtifactAsync = downloadArtifactAsync;
-const errors_1 = require("@expo/eas-build-job/dist/errors");
+const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
 const node_fetch_1 = __importDefault(require("node-fetch"));
@@ -52,11 +52,11 @@ function createDownloadArtifactFunction() {
             });
             const interpolationContext = stepsCtx.global.getInterpolationContext();
             if (!('workflow' in interpolationContext)) {
-                throw new errors_1.UserFacingError('EAS_DOWNLOAD_ARTIFACT_NO_WORKFLOW', 'No workflow found in the interpolation context.');
+                throw new eas_build_job_1.UserError('EAS_DOWNLOAD_ARTIFACT_NO_WORKFLOW', 'No workflow found in the interpolation context.');
             }
             const robotAccessToken = stepsCtx.global.staticContext.job.secrets?.robotAccessToken;
             if (!robotAccessToken) {
-                throw new errors_1.UserFacingError('EAS_DOWNLOAD_ARTIFACT_NO_ROBOT_ACCESS_TOKEN', 'No robot access token found in the job secrets.');
+                throw new eas_build_job_1.UserError('EAS_DOWNLOAD_ARTIFACT_NO_ROBOT_ACCESS_TOKEN', 'No robot access token found in the job secrets.');
             }
             const workflowRunId = interpolationContext.workflow.id;
             const { logger } = stepsCtx;

package/dist/steps/functions/downloadBuild.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDownloadBuildFunction = createDownloadBuildFunction;
 exports.downloadBuildAsync = downloadBuildAsync;
-const errors_1 = require("@expo/eas-build-job/dist/errors");
+const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
 const fast_glob_1 = require("fast-glob");
@@ -98,7 +98,7 @@ async function downloadBuildAsync({ logger, buildId, expoApiServerURL, robotAcce
         onlyDirectories: false,
     });
     if (matchingFiles.length === 0) {
-        throw new errors_1.UserFacingError('EAS_DOWNLOAD_BUILD_NO_MATCHING_FILES', `No ${extensions.map(ext => `.${ext}`).join(', ')} entries found in the archive.`);
+        throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_NO_MATCHING_FILES', `No ${extensions.map(ext => `.${ext}`).join(', ')} entries found in the archive.`);
     }
     logger.info(`Found ${matchingFiles.length} matching ${(0, strings_1.pluralize)(matchingFiles.length, 'entry')}:\n${matchingFiles.map(f => `- ${node_path_1.default.relative(extractionDirectory, f)}`).join('\n')}`);
     return { artifactPath: matchingFiles[0] };

package/dist/steps/functions/internalMaestroTest.js

@@ -18,6 +18,7 @@ const zod_1 = require("zod");
 const AndroidEmulatorUtils_1 = require("../../utils/AndroidEmulatorUtils");
 const IosSimulatorUtils_1 = require("../../utils/IosSimulatorUtils");
 const findMaestroPathsFlowsToExecuteAsync_1 = require("../../utils/findMaestroPathsFlowsToExecuteAsync");
+const retry_1 = require("../../utils/retry");
 const strings_1 = require("../../utils/strings");
 function createInternalEasMaestroTestFunction(ctx) {
     return new steps_1.BuildFunction({
@@ -176,14 +177,14 @@ function createInternalEasMaestroTestFunction(ctx) {
             const failedFlows = [];
             for (const [flowIndex, flowPath] of flowPathsToExecute.entries()) {
                 stepCtx.logger.info('');
-                // If output_format is empty or noop, we won't use this.
-                const outputPath = node_path_1.default.join(maestroReportsDir, [
-                    `${output_format ? output_format + '-' : ''}report-flow-${flowIndex + 1}`,
-                    MaestroOutputFormatToExtensionMap[output_format ?? 'noop'],
-                ]
-                    .filter(Boolean)
-                    .join('.'));
                 for (let attemptCount = 0; attemptCount < retries; attemptCount++) {
+                    // Generate unique report path per attempt (not overwritten on retry)
+                    const outputPath = node_path_1.default.join(maestroReportsDir, [
+                        `${output_format ? output_format + '-' : ''}report-flow-${flowIndex + 1}-attempt-${attemptCount}`,
+                        MaestroOutputFormatToExtensionMap[output_format ?? 'noop'],
+                    ]
+                        .filter(Boolean)
+                        .join('.'));
                     const localDeviceName = `eas-simulator-${flowIndex}-${attemptCount}`;
                     // If the test passes, but the recording fails, we don't want to make the test fail,
                     // so we return two separate results.
@@ -226,11 +227,7 @@ function createInternalEasMaestroTestFunction(ctx) {
                     if (logsResult?.ok) {
                         try {
                             const extension = node_path_1.default.extname(logsResult.value.outputPath);
-                            const destinationPath = node_path_1.default.join(deviceLogsDir, `flow-${flowIndex}${extension}`);
-                            await node_fs_1.default.promises.rm(destinationPath, {
-                                force: true,
-                                recursive: true,
-                            });
+                            const destinationPath = node_path_1.default.join(deviceLogsDir, `flow-${flowIndex}-attempt-${attemptCount}${extension}`);
                             await node_fs_1.default.promises.rename(logsResult.value.outputPath, destinationPath);
                         }
                         catch (err) {
@@ -344,9 +341,11 @@ const MaestroOutputFormatToExtensionMap = {
     junit: 'xml',
     html: 'html',
 };
+const ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS = [60_000, 120_000, 180_000];
+const ANDROID_STARTUP_RETRIES_COUNT = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length - 1;
 async function withCleanDeviceAsync({ platform, sourceDeviceIdentifier, localDeviceName, env, logger, fn, }) {
     // Clone and start the device
-    let localDeviceIdentifier;
+    let localDeviceIdentifier = null;
     switch (platform) {
         case 'ios': {
             logger.info(`Cloning iOS Simulator ${sourceDeviceIdentifier} to ${localDeviceName}...`);
@@ -369,27 +368,69 @@ async function withCleanDeviceAsync({ platform, sourceDeviceIdentifier, localDev
             break;
         }
         case 'android': {
-            logger.info(`Cloning Android Emulator ${sourceDeviceIdentifier} to ${localDeviceName}...`);
-            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.cloneAsync({
-                sourceDeviceName: sourceDeviceIdentifier,
-                destinationDeviceName: localDeviceName,
-                env,
+            await (0, retry_1.retryAsync)(async (attemptCount) => {
+                const timeoutMs = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS[attemptCount];
+                const attempt = attemptCount + 1;
+                const maxAttempts = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length;
+                let serialId = null;
+                try {
+                    logger.info(`Cloning Android Emulator ${sourceDeviceIdentifier} to ${localDeviceName} (attempt ${attempt}/${maxAttempts})...`);
+                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.cloneAsync({
+                        sourceDeviceName: sourceDeviceIdentifier,
+                        destinationDeviceName: localDeviceName,
+                        env,
+                        logger,
+                    });
+                    logger.info(`Starting Android Emulator ${localDeviceName} (attempt ${attempt}/${maxAttempts})...`);
+                    const startResult = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.startAsync({
+                        deviceName: localDeviceName,
+                        env,
+                    });
+                    serialId = startResult.serialId;
+                    logger.info(`Waiting for Android Emulator ${localDeviceName} to be ready...`);
+                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.waitForReadyAsync({
+                        serialId,
+                        env,
+                        timeoutMs,
+                        logger,
+                    });
+                    localDeviceIdentifier = serialId;
+                }
+                catch (err) {
+                    logger.warn({ err }, `Failed to start Android Emulator ${localDeviceName} on attempt ${attempt}/${maxAttempts}.`);
+                    try {
+                        if (serialId) {
+                            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.deleteAsync({
+                                serialId,
+                                deviceName: localDeviceName,
+                                env,
+                            });
+                        }
+                        else {
+                            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.deleteAsync({
+                                deviceName: localDeviceName,
+                                env,
+                            });
+                        }
+                    }
+                    catch (cleanupErr) {
+                        logger.warn({ err: cleanupErr }, `Failed to clean up Android Emulator ${localDeviceName}.`);
+                    }
+                    throw err;
+                }
+            }, {
                 logger,
+                retryOptions: {
+                    retries: ANDROID_STARTUP_RETRIES_COUNT,
+                    retryIntervalMs: 1_000,
+                },
             });
-            logger.info(`Starting Android Emulator ${localDeviceName}...`);
-            const { serialId } = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.startAsync({
-                deviceName: localDeviceName,
-                env,
-            });
-            logger.info(`Waiting for Android Emulator ${localDeviceName} to be ready...`);
-            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.waitForReadyAsync({
-                serialId,
-                env,
-            });
-            localDeviceIdentifier = serialId;
             break;
         }
     }
+    if (!localDeviceIdentifier) {
+        throw new Error('Device did not return an identifier after startup.');
+    }
     // Run the function
     const fnResult = await (0, results_1.asyncResult)(fn({ deviceIdentifier: localDeviceIdentifier }));
     // Stop the device

package/dist/steps/functions/maestroResultParser.js

@@ -23,6 +23,68 @@ const xmlParser = new fast_xml_parser_1.XMLParser({
     // Ensure single-element arrays are always arrays
     isArray: name => ['testsuite', 'testcase', 'property'].includes(name),
 });
+// Internal helper — not exported. Parses a single JUnit XML file.
+async function parseJUnitFile(filePath) {
+    const results = [];
+    try {
+        const content = await promises_1.default.readFile(filePath, 'utf-8');
+        const parsed = xmlParser.parse(content);
+        const testsuites = parsed?.testsuites?.testsuite;
+        if (!Array.isArray(testsuites)) {
+            return results;
+        }
+        for (const suite of testsuites) {
+            const testcases = suite?.testcase;
+            if (!Array.isArray(testcases)) {
+                continue;
+            }
+            for (const tc of testcases) {
+                const name = tc['@_name'];
+                if (!name) {
+                    continue;
+                }
+                const timeStr = tc['@_time'];
+                const timeSeconds = timeStr ? parseFloat(timeStr) : 0;
+                const duration = Number.isFinite(timeSeconds) ? Math.round(timeSeconds * 1000) : 0;
+                const status = tc['@_status'] === 'SUCCESS' ? 'passed' : 'failed';
+                const failureText = tc.failure != null
+                    ? typeof tc.failure === 'string'
+                        ? tc.failure
+                        : (tc.failure?.['#text'] ?? null)
+                    : null;
+                const errorText = tc.error != null
+                    ? typeof tc.error === 'string'
+                        ? tc.error
+                        : (tc.error?.['#text'] ?? null)
+                    : null;
+                const errorMessage = failureText ?? errorText ?? null;
+                const rawProperties = tc.properties?.property ?? [];
+                const properties = {};
+                for (const prop of rawProperties) {
+                    const propName = prop['@_name'];
+                    const value = prop['@_value'];
+                    if (typeof propName !== 'string' || typeof value !== 'string') {
+                        continue;
+                    }
+                    properties[propName] = value;
+                }
+                const tagsValue = properties['tags'];
+                const tags = tagsValue
+                    ? tagsValue
+                        .split(',')
+                        .map(t => t.trim())
+                        .filter(Boolean)
+                    : [];
+                delete properties['tags'];
+                results.push({ name, status, duration, errorMessage, tags, properties });
+            }
+        }
+    }
+    catch {
+        // Skip malformed XML files
+    }
+    return results;
+}
 async function parseJUnitTestCases(junitDirectory) {
     let entries;
     try {
@@ -37,68 +99,7 @@ async function parseJUnitTestCases(junitDirectory) {
     }
     const results = [];
     for (const xmlFile of xmlFiles) {
-        try {
-            const content = await promises_1.default.readFile(path_1.default.join(junitDirectory, xmlFile), 'utf-8');
-            const parsed = xmlParser.parse(content);
-            const testsuites = parsed?.testsuites?.testsuite;
-            if (!Array.isArray(testsuites)) {
-                continue;
-            }
-            for (const suite of testsuites) {
-                const testcases = suite?.testcase;
-                if (!Array.isArray(testcases)) {
-                    continue;
-                }
-                for (const tc of testcases) {
-                    const name = tc['@_name'];
-                    if (!name) {
-                        continue;
-                    }
-                    const timeStr = tc['@_time'];
-                    const timeSeconds = timeStr ? parseFloat(timeStr) : 0;
-                    const duration = Number.isFinite(timeSeconds) ? Math.round(timeSeconds * 1000) : 0;
-                    // Use @_status as primary indicator (more robust than checking <failure> presence)
-                    const status = tc['@_status'] === 'SUCCESS' ? 'passed' : 'failed';
-                    // Extract error message from <failure> or <error> elements
-                    const failureText = tc.failure != null
-                        ? typeof tc.failure === 'string'
-                            ? tc.failure
-                            : (tc.failure?.['#text'] ?? null)
-                        : null;
-                    const errorText = tc.error != null
-                        ? typeof tc.error === 'string'
-                            ? tc.error
-                            : (tc.error?.['#text'] ?? null)
-                        : null;
-                    const errorMessage = failureText ?? errorText ?? null;
-                    // Extract properties
-                    const rawProperties = tc.properties?.property ?? [];
-                    const properties = {};
-                    for (const prop of rawProperties) {
-                        const propName = prop['@_name'];
-                        const value = prop['@_value'];
-                        if (typeof propName !== 'string' || typeof value !== 'string') {
-                            continue;
-                        }
-                        properties[propName] = value;
-                    }
-                    // Extract tags from "tags" property (Maestro 2.2.0+, comma-separated)
-                    const tagsValue = properties['tags'];
-                    const tags = tagsValue
-                        ? tagsValue
-                            .split(',')
-                            .map(t => t.trim())
-                            .filter(Boolean)
-                        : [];
-                    delete properties['tags'];
-                    results.push({ name, status, duration, errorMessage, tags, properties });
-                }
-            }
-        }
-        catch {
-            // Skip malformed XML files
-            continue;
-        }
+        results.push(...(await parseJUnitFile(path_1.default.join(junitDirectory, xmlFile))));
     }
     return results;
 }
@@ -130,9 +131,26 @@ async function parseFlowMetadata(filePath) {
     }
 }
 async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot) {
-    // 1. Parse JUnit XML files (primary source)
-    const junitResults = await parseJUnitTestCases(junitDirectory);
-    if (junitResults.length === 0) {
+    // 1. Parse JUnit XML files, tracking which file each result came from
+    let junitEntries;
+    try {
+        junitEntries = await promises_1.default.readdir(junitDirectory);
+    }
+    catch {
+        return [];
+    }
+    const xmlFiles = junitEntries.filter(f => f.endsWith('.xml')).sort();
+    if (xmlFiles.length === 0) {
+        return [];
+    }
+    const junitResultsWithSource = [];
+    for (const xmlFile of xmlFiles) {
+        const fileResults = await parseJUnitFile(path_1.default.join(junitDirectory, xmlFile));
+        for (const result of fileResults) {
+            junitResultsWithSource.push({ result, sourceFile: xmlFile });
+        }
+    }
+    if (junitResultsWithSource.length === 0) {
         return [];
     }
     // 2. Parse ai-*.json from debug output for flow_file_path + retryCount
@@ -172,23 +190,59 @@ async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot)
     }
     // 3. Merge: JUnit results + ai-*.json metadata
     const results = [];
-    for (const junit of junitResults) {
-        const flowFilePath = flowPathMap.get(junit.name);
+    // Parse attempt index from filename pattern: *-attempt-N.*
+    const ATTEMPT_PATTERN = /attempt-(\d+)/;
+    // Group results by flow name
+    const resultsByName = new Map();
+    for (const entry of junitResultsWithSource) {
+        const group = resultsByName.get(entry.result.name) ?? [];
+        group.push(entry);
+        resultsByName.set(entry.result.name, group);
+    }
+    for (const [flowName, flowEntries] of resultsByName) {
+        const flowFilePath = flowPathMap.get(flowName);
         const relativePath = flowFilePath
             ? await relativizePathAsync(flowFilePath, projectRoot)
-            : junit.name; // fallback: use flow name if ai-*.json not found
-        const occurrences = flowOccurrences.get(junit.name) ?? 0;
-        const retryCount = Math.max(0, occurrences - 1);
-        results.push({
-            name: junit.name,
-            path: relativePath,
-            status: junit.status,
-            errorMessage: junit.errorMessage,
-            duration: junit.duration,
-            retryCount,
-            tags: junit.tags,
-            properties: junit.properties,
-        });
+            : flowName;
+        if (flowEntries.length === 1) {
+            // Single result for this flow — use ai-*.json occurrence count for retryCount
+            // (backward compat with old-style single JUnit file that gets overwritten)
+            const { result } = flowEntries[0];
+            const occurrences = flowOccurrences.get(flowName) ?? 0;
+            const retryCount = Math.max(0, occurrences - 1);
+            results.push({
+                name: flowName,
+                path: relativePath,
+                status: result.status,
+                errorMessage: result.errorMessage,
+                duration: result.duration,
+                retryCount,
+                tags: result.tags,
+                properties: result.properties,
+            });
+        }
+        else {
+            // Multiple results — per-attempt JUnit files. Sort by attempt index from filename.
+            const sorted = flowEntries
+                .map(entry => {
+                const match = entry.sourceFile.match(ATTEMPT_PATTERN);
+                const attemptIndex = match ? parseInt(match[1], 10) : 0;
+                return { ...entry, attemptIndex };
+            })
+                .sort((a, b) => a.attemptIndex - b.attemptIndex);
+            for (const { result, attemptIndex } of sorted) {
+                results.push({
+                    name: flowName,
+                    path: relativePath,
+                    status: result.status,
+                    errorMessage: result.errorMessage,
+                    duration: result.duration,
+                    retryCount: attemptIndex,
+                    tags: result.tags,
+                    properties: result.properties,
+                });
+            }
+        }
     }
     return results;
 }

package/dist/steps/functions/readIpaInfo.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createReadIpaInfoBuildFunction = createReadIpaInfoBuildFunction;
 exports.readIpaInfoAsync = readIpaInfoAsync;
-const errors_1 = require("@expo/eas-build-job/dist/errors");
+const eas_build_job_1 = require("@expo/eas-build-job");
 const steps_1 = require("@expo/steps");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -45,7 +45,7 @@ function createReadIpaInfoBuildFunction() {
             const ipaPathInput = zod_1.z.string().parse(inputs.ipa_path.value);
             const ipaPath = node_path_1.default.resolve(stepCtx.workingDirectory, ipaPathInput);
             if (!(await fs_extra_1.default.pathExists(ipaPath))) {
-                throw new errors_1.UserFacingError('EAS_READ_IPA_INFO_FILE_NOT_FOUND', `IPA file not found: ${ipaPath}`);
+                throw new eas_build_job_1.UserError('EAS_READ_IPA_INFO_FILE_NOT_FOUND', `IPA file not found: ${ipaPath}`);
             }
             const ipaInfo = await readIpaInfoAsync(ipaPath);
             outputs.bundle_identifier.set(ipaInfo.bundleIdentifier);
@@ -60,15 +60,15 @@ async function readIpaInfoAsync(ipaPath) {
         const infoPlist = parseInfoPlistBuffer(infoPlistBuffer);
         const bundleIdentifier = infoPlist.CFBundleIdentifier;
         if (typeof bundleIdentifier !== 'string') {
-            throw new errors_1.UserFacingError('EAS_READ_IPA_INFO_INVALID_INFO_PLIST', 'Failed to read IPA info: Missing or invalid CFBundleIdentifier in Info.plist');
+            throw new eas_build_job_1.UserError('EAS_READ_IPA_INFO_INVALID_INFO_PLIST', 'Failed to read IPA info: Missing or invalid CFBundleIdentifier in Info.plist');
         }
         const bundleShortVersion = infoPlist.CFBundleShortVersionString;
         if (typeof bundleShortVersion !== 'string') {
-            throw new errors_1.UserFacingError('EAS_READ_IPA_INFO_INVALID_INFO_PLIST', 'Failed to read IPA info: Missing or invalid CFBundleShortVersionString in Info.plist');
+            throw new eas_build_job_1.UserError('EAS_READ_IPA_INFO_INVALID_INFO_PLIST', 'Failed to read IPA info: Missing or invalid CFBundleShortVersionString in Info.plist');
         }
         const bundleVersion = infoPlist.CFBundleVersion;
         if (typeof bundleVersion !== 'string') {
-            throw new errors_1.UserFacingError('EAS_READ_IPA_INFO_INVALID_INFO_PLIST', 'Failed to read IPA info: Missing or invalid CFBundleVersion in Info.plist');
+            throw new eas_build_job_1.UserError('EAS_READ_IPA_INFO_INVALID_INFO_PLIST', 'Failed to read IPA info: Missing or invalid CFBundleVersion in Info.plist');
         }
         return {
             bundleIdentifier,
@@ -77,10 +77,10 @@ async function readIpaInfoAsync(ipaPath) {
         };
     }
     catch (error) {
-        if (error instanceof errors_1.UserFacingError) {
+        if (error instanceof eas_build_job_1.UserError) {
             throw error;
         }
-        throw new errors_1.UserFacingError('EAS_READ_IPA_INFO_FAILED', `Failed to read IPA info: ${error.message}`, { cause: error });
+        throw new eas_build_job_1.UserError('EAS_READ_IPA_INFO_FAILED', `Failed to read IPA info: ${error.message}`, { cause: error });
     }
 }
 function parseInfoPlistBuffer(data) {
@@ -89,7 +89,7 @@ function parseInfoPlistBuffer(data) {
         const parsedBinaryPlists = bplist_parser_1.default.parseBuffer(data);
         const parsedBinaryPlist = parsedBinaryPlists[0];
         if (!parsedBinaryPlist || typeof parsedBinaryPlist !== 'object') {
-            throw new errors_1.UserFacingError('EAS_READ_IPA_INFO_INVALID_BINARY_PLIST', 'Invalid binary plist in IPA');
+            throw new eas_build_job_1.UserError('EAS_READ_IPA_INFO_INVALID_BINARY_PLIST', 'Invalid binary plist in IPA');
         }
         return parsedBinaryPlist;
     }
@@ -101,7 +101,7 @@ async function readInfoPlistBufferFromIpaAsync(ipaPath) {
         const entries = Object.values(await zip.entries());
         const infoPlistEntry = entries.find(entry => INFO_PLIST_PATH_REGEXP.test(entry.name));
         if (!infoPlistEntry) {
-            throw new errors_1.UserFacingError('EAS_READ_IPA_INFO_INFO_PLIST_NOT_FOUND', `Failed to read IPA info: Could not find Info.plist in ${ipaPath}`);
+            throw new eas_build_job_1.UserError('EAS_READ_IPA_INFO_INFO_PLIST_NOT_FOUND', `Failed to read IPA info: Could not find Info.plist in ${ipaPath}`);
         }
         return await zip.entryData(infoPlistEntry.name);
     }

package/dist/steps/functions/reportMaestroTestResults.js

@@ -56,13 +56,20 @@ function createReportMaestroTestResultsFunction(ctx) {
                     logger.info('No maestro test results found, skipping report');
                     return;
                 }
-                // Maestro allows overriding flow names via config, so different flow files can share
-                // the same name. JUnit XML only contains names (not file paths), making it impossible
-                // to map duplicates back to their original flow files. Skip and let the user fix it.
-                const names = flowResults.map(r => r.name);
-                const duplicates = names.filter((n, i) => names.indexOf(n) !== i);
-                if (duplicates.length > 0) {
-                    logger.error(`Duplicate test case names found in JUnit output: ${[...new Set(duplicates)].join(', ')}. Skipping report. Ensure each Maestro flow has a unique name.`);
+                // Detect truly conflicting results: same (name, retryCount) pair means different flow files
+                // share the same name (Maestro config override), which we can't disambiguate.
+                // Same name with different retryCount is expected (per-attempt results from retries).
+                const seen = new Set();
+                const conflicting = new Set();
+                for (const r of flowResults) {
+                    const key = `${r.name}:${r.retryCount}`;
+                    if (seen.has(key)) {
+                        conflicting.add(r.name);
+                    }
+                    seen.add(key);
+                }
+                if (conflicting.size > 0) {
+                    logger.error(`Duplicate test case names found in JUnit output: ${[...conflicting].join(', ')}. Skipping report. Ensure each Maestro flow has a unique name.`);
                     return;
                 }
                 const testCaseResults = flowResults.flatMap(f => {

package/dist/steps/functions/restoreCache.js

@@ -89,10 +89,6 @@ function createRestoreCacheFunction() {
         fn: async (stepsCtx, { env, inputs, outputs }) => {
             const { logger } = stepsCtx;
             try {
-                if (stepsCtx.global.staticContext.job.platform) {
-                    logger.error('Caches are not supported in build jobs yet.');
-                    return;
-                }
                 const paths = zod_1.default
                     .array(zod_1.default.string())
                     .parse((inputs.path.value ?? '').split(/[\r\n]+/))