@expo/build-tools 18.7.0 → 18.8.0

package/dist/steps/functions/export.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEasExportBuildFunction = createEasExportBuildFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const packageManager_1 = require("../../utils/packageManager");
+const project_1 = require("../../utils/project");
+function createEasExportBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'export',
+        name: 'Export',
+        __metricsId: 'eas/export',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'output_dir',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+                defaultValue: 'dist',
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'dev',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'minify',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'dump_assetmap',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'ssg',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'api_only',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'platform',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+                defaultValue: 'web',
+            }),
+        ],
+        outputProviders: [
+            steps_1.BuildStepOutput.createProvider({
+                id: 'export_dir',
+                required: true,
+            }),
+        ],
+        fn: async (stepsCtx, { inputs, outputs, env }) => {
+            const outputDir = inputs.output_dir.value;
+            const dev = inputs.dev.value;
+            const minify = inputs.minify.value;
+            const dumpAssetmap = inputs.dump_assetmap.value;
+            const ssg = inputs.ssg.value;
+            const apiOnly = inputs.api_only.value;
+            const platform = inputs.platform.value;
+            const packageManager = (0, packageManager_1.resolvePackageManager)(stepsCtx.workingDirectory, { env });
+            const exportCommand = getExportCommand({
+                outputDir,
+                dev,
+                minify,
+                dumpAssetmap,
+                ssg,
+                apiOnly,
+                platform,
+            });
+            stepsCtx.logger.info(`Running export command: expo ${exportCommand.join(' ')}`);
+            try {
+                await (0, project_1.runExpoCliCommand)({
+                    packageManager,
+                    args: exportCommand,
+                    options: {
+                        cwd: stepsCtx.workingDirectory,
+                        env,
+                        logger: stepsCtx.logger,
+                        stdio: 'pipe',
+                    },
+                });
+                outputs.export_dir.set(outputDir);
+            }
+            catch (error) {
+                throw new eas_build_job_1.UserError('EXPO_EXPORT_FAILED', `Export command failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+            }
+        },
+    });
+}
+function getExportCommand({ outputDir, dev, minify, dumpAssetmap, ssg, apiOnly, platform, }) {
+    const exportCommand = ['export', '--output-dir', outputDir, '--platform', platform];
+    if (dev) {
+        exportCommand.push('--dev');
+    }
+    if (minify === false) {
+        exportCommand.push('--no-minify');
+    }
+    if (dumpAssetmap) {
+        exportCommand.push('--dump-assetmap');
+    }
+    if (ssg === false) {
+        exportCommand.push('--no-ssg');
+    }
+    if (apiOnly) {
+        exportCommand.push('--api-only');
+    }
+    return exportCommand;
+}

package/dist/steps/functions/generateGymfileFromTemplate.js

@@ -10,6 +10,7 @@ const steps_1 = require("@expo/steps");
 const template_file_1 = require("@expo/template-file");
 const assert_1 = __importDefault(require("assert"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const credentials_1 = require("../utils/ios/credentials/credentials");
 const manager_1 = __importDefault(require("../utils/ios/credentials/manager"));
@@ -38,6 +39,10 @@ const DEFAULT_CREDENTIALS_TEMPLATE = `
     disable_xcpretty(true)
     buildlog_path("<%- LOGS_DIRECTORY %>")
 
+    derived_data_path("<%- DERIVED_DATA_PATH %>")
+    result_bundle(true)
+    result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
+
     output_directory("<%- OUTPUT_DIRECTORY %>")
 `;
 const DEFAULT_SIMULATOR_TEMPLATE = `
@@ -56,6 +61,9 @@ const DEFAULT_SIMULATOR_TEMPLATE = `
 
     disable_xcpretty(true)
     buildlog_path("<%- LOGS_DIRECTORY %>")
+
+    result_bundle(true)
+    result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
 `;
 function generateGymfileFromTemplateFunction() {
     return new steps_1.BuildFunction({
@@ -158,6 +166,7 @@ function generateGymfileFromTemplateFunction() {
                     ICLOUD_CONTAINER_ENVIRONMENT,
                     SCHEME_SIMULATOR_DESTINATION: simulatorDestination,
                     DERIVED_DATA_PATH: './build',
+                    RESULT_BUNDLE_PATH: path_1.default.join(os_1.default.tmpdir(), `result-bundle-${Date.now()}.xcresult`),
                     ...(PROFILES ? { PROFILES } : {}),
                     ...(credentials
                         ? {

package/dist/steps/functions/installNodeModules.js

@@ -23,7 +23,7 @@ function createInstallNodeModulesBuildFunction() {
 }
 async function installNodeModules(stepCtx, env) {
     const { logger } = stepCtx;
-    const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory);
+    const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory, { env });
     const packagerRunDir = (0, packageManager_1.findPackagerRootDir)(stepCtx.workingDirectory);
     if (packagerRunDir !== stepCtx.workingDirectory) {
         const relativeReactNativeProjectDirectory = path_1.default.relative(stepCtx.global.projectTargetDirectory, stepCtx.workingDirectory);

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

@@ -0,0 +1,2 @@
+import { BuildFunction } from '@expo/steps';
+export declare function parseXcactivitylogFunction(): BuildFunction;

package/dist/steps/functions/parseXcactivitylog.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseXcactivitylogFunction = parseXcactivitylogFunction;
+const steps_1 = require("@expo/steps");
+const path_1 = __importDefault(require("path"));
+const xcactivitylog_1 = require("../utils/ios/xcactivitylog");
+function parseXcactivitylogFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'parse_xcactivitylog',
+        name: 'Analyze build performance',
+        __metricsId: 'eas/parse_xcactivitylog',
+        supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'derived_data_path',
+                required: false,
+                defaultValue: 'ios/build',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'workspace_path',
+                required: false,
+                defaultValue: 'ios',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'xclogparser_version',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        fn: async (stepCtx, { inputs, env }) => {
+            const derivedDataPath = inputs.derived_data_path.value;
+            const workspacePath = inputs.workspace_path.value;
+            const version = inputs.xclogparser_version.value;
+            await (0, xcactivitylog_1.parseAndReportXcactivitylog)({
+                derivedDataPath: path_1.default.resolve(stepCtx.workingDirectory, derivedDataPath),
+                workspacePath: path_1.default.resolve(stepCtx.workingDirectory, workspacePath),
+                xclogparserVersion: version,
+                logger: stepCtx.logger,
+                proxyBaseUrl: env.EAS_BUILD_COCOAPODS_CACHE_URL,
+            });
+        },
+    });
+}

package/dist/steps/functions/prebuild.js

@@ -35,7 +35,7 @@ function createPrebuildBuildFunction() {
         fn: async (stepCtx, { inputs, env }) => {
             const { logger } = stepCtx;
             const appleTeamId = inputs.apple_team_id.value;
-            const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory);
+            const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory, { env });
             const defaultPlatform = process.platform === 'darwin' ? 'ios' : 'android';
             const job = stepCtx.global.staticContext.job;
             const prebuildCommandArgs = getPrebuildCommandArgs({

package/dist/steps/functions/restoreBuildCache.js

@@ -154,7 +154,7 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
     }
 }
 async function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets, }) {
-    if (env.EXPERIMENTAL_EAS_GRADLE_CACHE !== '1') {
+    if (env.EAS_GRADLE_CACHE !== '1') {
         return;
     }
     try {

package/dist/steps/functions/saveBuildCache.js

@@ -112,7 +112,7 @@ async function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBe
     }
 }
 async function saveGradleCacheAsync({ logger, workingDirectory, env, secrets, }) {
-    if (env.EXPERIMENTAL_EAS_GRADLE_CACHE !== '1') {
+    if (env.EAS_GRADLE_CACHE !== '1') {
         return;
     }
     const gradleCachesPath = path_1.default.join(os_1.default.homedir(), '.gradle', 'caches');

package/dist/steps/utils/ios/xcactivitylog.d.ts

@@ -0,0 +1,57 @@
+import { bunyan } from '@expo/logger';
+import { z } from 'zod';
+/**
+ * Download xclogparser, parse xcactivitylog from derived data, and log a
+ * compile metrics report. Never throws — all errors are logged at debug level.
+ *
+ * Can be called from both the step-based flow (BuildFunction) and the
+ * traditional builder flow (runBuildPhase).
+ */
+export declare function parseAndReportXcactivitylog({ derivedDataPath, workspacePath, xclogparserVersion, logger, proxyBaseUrl, }: {
+    derivedDataPath: string;
+    workspacePath: string;
+    xclogparserVersion?: string;
+    logger: bunyan;
+    proxyBaseUrl?: string;
+}): Promise<void>;
+declare const XcactivitylogStepSchemaZ: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    detailStepType: z.ZodOptional<z.ZodString>;
+    signature: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    startTimestamp: z.ZodOptional<z.ZodNumber>;
+    endTimestamp: z.ZodOptional<z.ZodNumber>;
+    subSteps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const XcactivitylogDataSchemaZ: z.ZodObject<{
+    schema: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    subSteps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        detailStepType: z.ZodOptional<z.ZodString>;
+        signature: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        startTimestamp: z.ZodOptional<z.ZodNumber>;
+        endTimestamp: z.ZodOptional<z.ZodNumber>;
+        subSteps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type XcactivitylogStep = z.infer<typeof XcactivitylogStepSchemaZ>;
+type XcactivitylogData = z.infer<typeof XcactivitylogDataSchemaZ>;
+interface TargetMetric {
+    moduleName: string;
+    taskSeconds: number;
+    wallSpan: number;
+    activeWallTime: number;
+}
+export declare function isCompileStep(step: Partial<XcactivitylogStep>): boolean;
+export declare function collectTopLevelCompileSteps(step: XcactivitylogStep, results?: XcactivitylogStep[]): XcactivitylogStep[];
+export declare function buildTargetMetrics(data: XcactivitylogData, { minTaskSeconds }?: {
+    minTaskSeconds?: number;
+}): {
+    results: TargetMetric[];
+    totalTaskSeconds: number;
+};
+export declare function formatReport(data: XcactivitylogData): string;
+export {};

package/dist/steps/utils/ios/xcactivitylog.js

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAndReportXcactivitylog = parseAndReportXcactivitylog;
+exports.isCompileStep = isCompileStep;
+exports.collectTopLevelCompileSteps = collectTopLevelCompileSteps;
+exports.buildTargetMetrics = buildTargetMetrics;
+exports.formatReport = formatReport;
+const downloader_1 = __importDefault(require("@expo/downloader"));
+const results_1 = require("@expo/results");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const DEFAULT_XCLOGPARSER_VERSION = 'v0.2.46';
+const XCLOGPARSER_DOWNLOAD_URL = 'https://storage.googleapis.com/turtle-v2/xclogparser';
+const XCLOGPARSER_DOWNLOAD_TIMEOUT_MS = 20_000;
+const XCLOGPARSER_OUTPUT_FILENAME = 'xcactivitylog.json';
+/**
+ * Download xclogparser, parse xcactivitylog from derived data, and log a
+ * compile metrics report. Never throws — all errors are logged at debug level.
+ *
+ * Can be called from both the step-based flow (BuildFunction) and the
+ * traditional builder flow (runBuildPhase).
+ */
+async function parseAndReportXcactivitylog({ derivedDataPath, workspacePath, xclogparserVersion = DEFAULT_XCLOGPARSER_VERSION, logger, proxyBaseUrl, }) {
+    let tempDir;
+    try {
+        tempDir = await fs_extra_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'xclogparser-'));
+        const xclogparserPath = await downloadXclogparser(tempDir, xclogparserVersion, logger, proxyBaseUrl);
+        const jsonOutputPath = await runXclogparser({
+            binaryPath: xclogparserPath,
+            derivedDataPath,
+            workspacePath,
+            outputDir: tempDir,
+        });
+        const data = XcactivitylogDataSchemaZ.parse(JSON.parse(await fs_extra_1.default.readFile(jsonOutputPath, 'utf8')));
+        logger.info(formatReport(data));
+    }
+    catch (err) {
+        logger.debug({ err }, 'Failed to analyze build performance; continuing without a report');
+    }
+    finally {
+        if (tempDir) {
+            await (0, results_1.asyncResult)(fs_extra_1.default.rm(tempDir, { force: true, recursive: true }));
+        }
+    }
+}
+async function downloadXclogparser(tempDir, version, logger, proxyBaseUrl) {
+    const zipName = getXclogparserZipName(version);
+    const zipPath = path_1.default.join(tempDir, zipName);
+    const directUrl = `${XCLOGPARSER_DOWNLOAD_URL}/${zipName}`;
+    const proxiedUrl = getProxiedDownloadUrl({ directUrl, proxyBaseUrl });
+    if (proxiedUrl) {
+        const proxiedDownloadResult = await (0, results_1.asyncResult)(downloadAndUnpackXclogparser({ tempDir, zipPath, sourceUrl: proxiedUrl }));
+        if (!proxiedDownloadResult.ok) {
+            logger.debug({ err: proxiedDownloadResult.reason }, 'Failed to prepare xclogparser via the proxy path; falling back to the direct URL');
+            await cleanupXclogparserArtifacts({ tempDir, zipPath });
+        }
+        else {
+            return proxiedDownloadResult.value;
+        }
+    }
+    return await downloadAndUnpackXclogparser({ tempDir, zipPath, sourceUrl: directUrl });
+}
+async function downloadAndUnpackXclogparser({ tempDir, zipPath, sourceUrl, }) {
+    await (0, downloader_1.default)(sourceUrl, zipPath, { retry: 3, timeout: XCLOGPARSER_DOWNLOAD_TIMEOUT_MS });
+    return await unpackXclogparser({ tempDir, zipPath });
+}
+async function unpackXclogparser({ tempDir, zipPath, }) {
+    await (0, turtle_spawn_1.default)('unzip', ['-q', zipPath, '-d', tempDir], { stdio: 'pipe' });
+    const binaryPath = path_1.default.join(tempDir, 'xclogparser');
+    await fs_extra_1.default.chmod(binaryPath, 0o755);
+    return binaryPath;
+}
+async function cleanupXclogparserArtifacts({ tempDir, zipPath, }) {
+    await (0, results_1.asyncResult)(fs_extra_1.default.rm(zipPath, { force: true }));
+    await (0, results_1.asyncResult)(fs_extra_1.default.rm(path_1.default.join(tempDir, 'xclogparser'), { force: true }));
+}
+async function runXclogparser({ binaryPath, derivedDataPath, workspacePath, outputDir, }) {
+    const outputPath = path_1.default.join(outputDir, XCLOGPARSER_OUTPUT_FILENAME);
+    await (0, turtle_spawn_1.default)(binaryPath, [
+        'parse',
+        '--derived_data',
+        derivedDataPath,
+        '--workspace',
+        workspacePath,
+        '--reporter',
+        'json',
+        '--output',
+        outputPath,
+    ], { stdio: 'pipe' });
+    return outputPath;
+}
+const XcactivitylogStepSchemaZ = zod_1.z.object({
+    title: zod_1.z.string().optional(),
+    detailStepType: zod_1.z.string().optional(),
+    signature: zod_1.z.string().optional(),
+    duration: zod_1.z.number().optional(),
+    startTimestamp: zod_1.z.number().optional(),
+    endTimestamp: zod_1.z.number().optional(),
+    get subSteps() {
+        return zod_1.z.array(XcactivitylogStepSchemaZ).optional();
+    },
+});
+const XcactivitylogDataSchemaZ = zod_1.z.object({
+    schema: zod_1.z.union([zod_1.z.string(), zod_1.z.object({ name: zod_1.z.string().optional() })]).optional(),
+    subSteps: zod_1.z.array(XcactivitylogStepSchemaZ).optional(),
+});
+const COMPILE_DETAIL_TYPES = new Set(['cCompilation', 'compileAssetsCatalog', 'compileStoryboard']);
+const COMPILE_SIGNATURE_PREFIXES = ['SwiftCompile ', 'SwiftGeneratePch '];
+function getXclogparserZipName(version) {
+    return `XCLogParser-macOS-x86-64-arm64-${version}.zip`;
+}
+function getProxiedDownloadUrl({ directUrl, proxyBaseUrl, }) {
+    if (!proxyBaseUrl) {
+        return null;
+    }
+    const parsedUrl = new URL(directUrl);
+    return directUrl.replace(`${parsedUrl.protocol}//${parsedUrl.host}`, `${proxyBaseUrl}/${parsedUrl.host}`);
+}
+function isCompileStep(step) {
+    const detailStepType = step.detailStepType ?? '';
+    const signature = step.signature ?? '';
+    if (COMPILE_DETAIL_TYPES.has(detailStepType)) {
+        return true;
+    }
+    return COMPILE_SIGNATURE_PREFIXES.some(prefix => signature.startsWith(prefix));
+}
+function collectTopLevelCompileSteps(step, results = []) {
+    for (const child of step.subSteps ?? []) {
+        if (isCompileStep(child)) {
+            results.push(child);
+            continue;
+        }
+        collectTopLevelCompileSteps(child, results);
+    }
+    return results;
+}
+function intervalFromStep(step) {
+    if (typeof step.startTimestamp !== 'number' || typeof step.endTimestamp !== 'number') {
+        return null;
+    }
+    return { start: step.startTimestamp, end: step.endTimestamp };
+}
+function computeActiveWallTime(intervals) {
+    if (intervals.length === 0) {
+        return 0;
+    }
+    const sorted = [...intervals].sort((a, b) => a.start - b.start);
+    let activeWallTime = 0;
+    let currentStart = sorted[0].start;
+    let currentEnd = sorted[0].end;
+    for (const interval of sorted.slice(1)) {
+        if (interval.start <= currentEnd) {
+            currentEnd = Math.max(currentEnd, interval.end);
+            continue;
+        }
+        activeWallTime += currentEnd - currentStart;
+        currentStart = interval.start;
+        currentEnd = interval.end;
+    }
+    activeWallTime += currentEnd - currentStart;
+    return activeWallTime;
+}
+function buildTargetMetrics(data, { minTaskSeconds = 0.5 } = {}) {
+    const results = [];
+    for (const step of data.subSteps ?? []) {
+        const title = step.title ?? '';
+        if (!title.startsWith('Build target ')) {
+            continue;
+        }
+        const moduleName = title.replace('Build target ', '');
+        const compileSteps = collectTopLevelCompileSteps(step);
+        const taskSeconds = compileSteps.reduce((sum, s) => sum + (s.duration ?? 0), 0);
+        if (taskSeconds < minTaskSeconds) {
+            continue;
+        }
+        const intervals = compileSteps.map(intervalFromStep).filter((i) => i !== null);
+        const minStart = intervals.length > 0 ? Math.min(...intervals.map(i => i.start)) : 0;
+        const maxEnd = intervals.length > 0 ? Math.max(...intervals.map(i => i.end)) : 0;
+        const wallSpan = intervals.length > 0 ? maxEnd - minStart : 0;
+        const activeWallTime = computeActiveWallTime(intervals);
+        results.push({ moduleName, taskSeconds, wallSpan, activeWallTime });
+    }
+    results.sort((a, b) => {
+        if (b.taskSeconds !== a.taskSeconds) {
+            return b.taskSeconds - a.taskSeconds;
+        }
+        if (b.wallSpan !== a.wallSpan) {
+            return b.wallSpan - a.wallSpan;
+        }
+        return a.moduleName.localeCompare(b.moduleName);
+    });
+    const totalTaskSeconds = results.reduce((sum, r) => sum + r.taskSeconds, 0);
+    return { results, totalTaskSeconds };
+}
+function formatSeconds(value) {
+    return `${value.toFixed(1)}s`;
+}
+function formatReport(data) {
+    const { results, totalTaskSeconds } = buildTargetMetrics(data);
+    const nameWidth = Math.max(6, ...results.map(r => r.moduleName.length)) + 2;
+    const taskWidth = 10;
+    const pctWidth = 8;
+    const wallWidth = 10;
+    const barMaxWidth = 20;
+    const maxTaskSeconds = results[0]?.taskSeconds ?? 1;
+    const header = '┌─' +
+        '─'.repeat(nameWidth) +
+        '─┬────────────┬──────────┬────────────┬─' +
+        '─'.repeat(barMaxWidth) +
+        '─┐';
+    const divider = '├─' +
+        '─'.repeat(nameWidth) +
+        '─┼────────────┼──────────┼────────────┼─' +
+        '─'.repeat(barMaxWidth) +
+        '─┤';
+    const footer = '└─' +
+        '─'.repeat(nameWidth) +
+        '─┴────────────┴──────────┴────────────┴─' +
+        '─'.repeat(barMaxWidth) +
+        '─┘';
+    const lines = [];
+    lines.push('');
+    lines.push('Xcode Build — Compile Metrics by Module');
+    lines.push(`Schema: ${typeof data.schema === 'string' ? data.schema : (data.schema?.name ?? 'unknown')}`);
+    lines.push('% Task = share of total Compile Task Seconds');
+    lines.push('Wall = first compile start to last compile end');
+    lines.push('');
+    lines.push(header);
+    lines.push('│ ' +
+        'Module'.padEnd(nameWidth) +
+        ' │ ' +
+        'Task'.padStart(taskWidth) +
+        ' │ ' +
+        '% Task'.padStart(pctWidth) +
+        ' │ ' +
+        'Wall'.padStart(wallWidth) +
+        ' │ ' +
+        ' '.repeat(barMaxWidth) +
+        ' │');
+    lines.push(divider);
+    for (const result of results) {
+        const pct = totalTaskSeconds === 0 ? 0 : (result.taskSeconds / totalTaskSeconds) * 100;
+        const barLength = Math.round((result.taskSeconds / maxTaskSeconds) * barMaxWidth);
+        const bar = '█'.repeat(barLength) + '░'.repeat(barMaxWidth - barLength);
+        lines.push('│ ' +
+            result.moduleName.padEnd(nameWidth) +
+            ' │ ' +
+            formatSeconds(result.taskSeconds).padStart(taskWidth) +
+            ' │ ' +
+            `${pct.toFixed(1)}%`.padStart(pctWidth) +
+            ' │ ' +
+            formatSeconds(result.wallSpan).padStart(wallWidth) +
+            ' │ ' +
+            bar +
+            ' │');
+    }
+    lines.push(divider);
+    lines.push('│ ' +
+        'TOTAL'.padEnd(nameWidth) +
+        ' │ ' +
+        formatSeconds(totalTaskSeconds).padStart(taskWidth) +
+        ' │ ' +
+        '100.0%'.padStart(pctWidth) +
+        ' │ ' +
+        'n/a'.padStart(wallWidth) +
+        ' │ ' +
+        ' '.repeat(barMaxWidth) +
+        ' │');
+    lines.push(footer);
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/templates/GymfileArchive.d.ts

@@ -1 +1 @@
-export declare const GymfileArchiveTemplate = "suppress_xcode_output(true)\nclean(<%- CLEAN %>)\n\nscheme(\"<%- SCHEME %>\")\n<% if (SCHEME_BUILD_CONFIGURATION) { %>\nconfiguration(\"<%- SCHEME_BUILD_CONFIGURATION %>\")\n<% } %>\n\nexport_options({\n  method: \"<%- EXPORT_METHOD %>\",\n  provisioningProfiles: {<% _.forEach(PROFILES, function(profile) { %>\n    \"<%- profile.BUNDLE_ID %>\" => \"<%- profile.UUID %>\",<% }); %>\n  }<% if (ICLOUD_CONTAINER_ENVIRONMENT) { %>,\n  iCloudContainerEnvironment: \"<%- ICLOUD_CONTAINER_ENVIRONMENT %>\"\n<% } %>\n})\n\nexport_xcargs \"OTHER_CODE_SIGN_FLAGS=\\\"--keychain <%- KEYCHAIN_PATH %>\\\"\"\n\ndisable_xcpretty(true)\nbuildlog_path(\"<%- LOGS_DIRECTORY %>\")\n\noutput_directory(\"<%- OUTPUT_DIRECTORY %>\")\n";
+export declare const GymfileArchiveTemplate = "suppress_xcode_output(true)\nclean(<%- CLEAN %>)\n\nscheme(\"<%- SCHEME %>\")\n<% if (SCHEME_BUILD_CONFIGURATION) { %>\nconfiguration(\"<%- SCHEME_BUILD_CONFIGURATION %>\")\n<% } %>\n\nexport_options({\n  method: \"<%- EXPORT_METHOD %>\",\n  provisioningProfiles: {<% _.forEach(PROFILES, function(profile) { %>\n    \"<%- profile.BUNDLE_ID %>\" => \"<%- profile.UUID %>\",<% }); %>\n  }<% if (ICLOUD_CONTAINER_ENVIRONMENT) { %>,\n  iCloudContainerEnvironment: \"<%- ICLOUD_CONTAINER_ENVIRONMENT %>\"\n<% } %>\n})\n\nexport_xcargs \"OTHER_CODE_SIGN_FLAGS=\\\"--keychain <%- KEYCHAIN_PATH %>\\\"\"\n\ndisable_xcpretty(true)\nbuildlog_path(\"<%- LOGS_DIRECTORY %>\")\n\nderived_data_path(\"<%- DERIVED_DATA_PATH %>\")\nresult_bundle(true)\nresult_bundle_path(\"<%- RESULT_BUNDLE_PATH %>\")\n\noutput_directory(\"<%- OUTPUT_DIRECTORY %>\")\n";

package/dist/templates/GymfileArchive.js

@@ -23,5 +23,9 @@ export_xcargs "OTHER_CODE_SIGN_FLAGS=\\"--keychain <%- KEYCHAIN_PATH %>\\""
 disable_xcpretty(true)
 buildlog_path("<%- LOGS_DIRECTORY %>")
 
+derived_data_path("<%- DERIVED_DATA_PATH %>")
+result_bundle(true)
+result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
+
 output_directory("<%- OUTPUT_DIRECTORY %>")
 `;

package/dist/templates/GymfileSimulator.d.ts

@@ -1 +1 @@
-export declare const GymfileSimulatorTemplate = "suppress_xcode_output(true)\nclean(<%- CLEAN %>)\n\nscheme(\"<%- SCHEME %>\")\n<% if (SCHEME_BUILD_CONFIGURATION) { %>\nconfiguration(\"<%- SCHEME_BUILD_CONFIGURATION %>\")\n<% } %>\n\nderived_data_path(\"<%- DERIVED_DATA_PATH %>\")\nskip_package_ipa(true)\nskip_archive(true)\ndestination(\"<%- SCHEME_SIMULATOR_DESTINATION %>\")\n\ndisable_xcpretty(true)\nbuildlog_path(\"<%- LOGS_DIRECTORY %>\")\n";
+export declare const GymfileSimulatorTemplate = "suppress_xcode_output(true)\nclean(<%- CLEAN %>)\n\nscheme(\"<%- SCHEME %>\")\n<% if (SCHEME_BUILD_CONFIGURATION) { %>\nconfiguration(\"<%- SCHEME_BUILD_CONFIGURATION %>\")\n<% } %>\n\nderived_data_path(\"<%- DERIVED_DATA_PATH %>\")\nskip_package_ipa(true)\nskip_archive(true)\ndestination(\"<%- SCHEME_SIMULATOR_DESTINATION %>\")\n\ndisable_xcpretty(true)\nbuildlog_path(\"<%- LOGS_DIRECTORY %>\")\n\nresult_bundle(true)\nresult_bundle_path(\"<%- RESULT_BUNDLE_PATH %>\")\n";

package/dist/templates/GymfileSimulator.js

@@ -16,4 +16,7 @@ destination("<%- SCHEME_SIMULATOR_DESTINATION %>")
 
 disable_xcpretty(true)
 buildlog_path("<%- LOGS_DIRECTORY %>")
+
+result_bundle(true)
+result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
 `;

package/dist/utils/easCli.d.ts

@@ -0,0 +1,11 @@
+import { SpawnOptions, SpawnResult } from '@expo/turtle-spawn';
+import { Env } from '@expo/eas-build-job';
+export declare function resolveEasCommandPrefixAndEnvAsync(): Promise<{
+    cmd: string;
+    args: string[];
+    extraEnv: Env;
+}>;
+export declare function runEasCliCommand({ args, options, }: {
+    args: string[];
+    options: SpawnOptions;
+}): Promise<SpawnResult>;