@expo/build-tools 20.5.1 → 21.0.0

package/dist/steps/utils/argentArtifacts.js

@@ -13,12 +13,14 @@ const node_fetch_1 = __importDefault(require("node-fetch"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const promises_2 = require("node:stream/promises");
+const promises_3 = require("node:timers/promises");
 const zod_1 = require("zod");
 const sentry_1 = require("../../sentry");
 const artifacts_1 = require("../../utils/artifacts");
-const retry_1 = require("../../utils/retry");
 const deviceRunSessionArtifacts_1 = require("./deviceRunSessionArtifacts");
 const ARGENT_ARTIFACT_UPLOAD_POLL_INTERVAL_MS = 5_000;
+const ARGENT_ARTIFACT_UPLOAD_CLEANUP_TIMEOUT_MS = 30_000;
+const ARGENT_ARTIFACT_FETCH_TIMEOUT_MS = 10_000;
 const ArgentArtifactSchema = zod_1.z.object({
     id: zod_1.z.string(),
     filename: zod_1.z.string(),
@@ -28,46 +30,73 @@ const ArgentArtifactSchema = zod_1.z.object({
 const ArgentArtifactsListResponseSchema = zod_1.z.object({
     artifacts: zod_1.z.array(ArgentArtifactSchema),
 });
-async function pollArgentArtifactsForUploadAsync(ctx, { deviceRunSessionId, toolsUrl, toolsAuthToken, logger, }) {
+async function pollArgentArtifactsForUploadAsync(ctx, { deviceRunSessionId, toolsUrl, toolsAuthToken, logger, signal, }) {
     logger.info('Started polling Argent tool-server for artifacts.');
     const seenArtifactIds = new Set();
+    const pendingUploads = new Set();
     let listArtifactsErrorCount = 0;
-    for (;;) {
+    const queueArtifactUpload = (artifact) => {
+        if (seenArtifactIds.has(artifact.id)) {
+            return;
+        }
+        seenArtifactIds.add(artifact.id);
+        const uploadPromise = uploadArgentArtifactAsync(ctx, {
+            deviceRunSessionId,
+            toolsUrl,
+            toolsAuthToken,
+            artifact,
+            logger,
+        }).catch(err => {
+            const error = err instanceof Error ? err : new Error(String(err));
+            sentry_1.Sentry.capture('Could not upload Argent remote session artifact', error);
+            logger.warn({ err: error }, 'Could not upload Argent remote session artifact.');
+        });
+        pendingUploads.add(uploadPromise);
+        void uploadPromise.finally(() => {
+            pendingUploads.delete(uploadPromise);
+        });
+    };
+    const listArtifactsForUploadAsync = async ({ signal, } = {}) => {
         try {
-            const artifacts = await listArgentArtifactsAsync({ toolsUrl, toolsAuthToken });
+            const artifacts = await listArgentArtifactsAsync({ toolsUrl, toolsAuthToken, signal });
             listArtifactsErrorCount = 0;
-            for (const artifact of artifacts) {
-                if (seenArtifactIds.has(artifact.id)) {
-                    continue;
-                }
-                seenArtifactIds.add(artifact.id);
-                void uploadArgentArtifactAsync(ctx, {
-                    deviceRunSessionId,
-                    toolsUrl,
-                    toolsAuthToken,
-                    artifact,
-                    logger,
-                }).catch(err => {
-                    const error = err instanceof Error ? err : new Error(String(err));
-                    sentry_1.Sentry.capture('Could not upload Argent remote session artifact', error);
-                    logger.warn({ err: error }, 'Could not upload Argent remote session artifact.');
-                });
-            }
+            return artifacts;
         }
         catch (err) {
+            if (signal?.aborted) {
+                return [];
+            }
             const error = err instanceof Error ? err : new Error(String(err));
             listArtifactsErrorCount += 1;
             if (listArtifactsErrorCount === 1 || listArtifactsErrorCount % 5 === 0) {
                 sentry_1.Sentry.capture('Could not list Argent remote session artifacts', error);
                 logger.warn({ err: error, failedArtifactListCount: listArtifactsErrorCount }, 'Could not list Argent remote session artifacts.');
             }
+            return [];
         }
-        await (0, retry_1.sleepAsync)(ARGENT_ARTIFACT_UPLOAD_POLL_INTERVAL_MS);
+    };
+    const listAndQueueArtifactUploadsAsync = async ({ signal, } = {}) => {
+        const artifacts = await listArtifactsForUploadAsync({ signal });
+        for (const artifact of artifacts) {
+            queueArtifactUpload(artifact);
+        }
+    };
+    while (!signal.aborted) {
+        await listAndQueueArtifactUploadsAsync({ signal });
+        await sleepUntilAbortedAsync(ARGENT_ARTIFACT_UPLOAD_POLL_INTERVAL_MS, signal);
     }
+    logger.info('Argent artifact polling stopped; draining remaining artifacts.');
+    await listAndQueueArtifactUploadsAsync();
+    await waitForPendingUploadsAsync({
+        pendingUploads,
+        timeoutMs: ARGENT_ARTIFACT_UPLOAD_CLEANUP_TIMEOUT_MS,
+        logger,
+    });
 }
-async function listArgentArtifactsAsync({ toolsUrl, toolsAuthToken, }) {
+async function listArgentArtifactsAsync({ toolsUrl, toolsAuthToken, signal, }) {
     const response = await (0, node_fetch_1.default)(new URL('/artifacts', toolsUrl).toString(), {
         headers: toolsAuthToken ? { Authorization: `Bearer ${toolsAuthToken}` } : {},
+        signal: createTimeoutSignal({ signal, timeoutMs: ARGENT_ARTIFACT_FETCH_TIMEOUT_MS }),
     });
     if (!response.ok) {
         throw new eas_build_job_1.SystemError(`Failed to list Argent artifacts: ${response.status} ${response.statusText}`);
@@ -97,6 +126,7 @@ async function uploadArgentArtifactAsync(ctx, { deviceRunSessionId, toolsUrl, to
             artifactId: artifact.id,
             name: `${filename} (${artifact.id})`,
             filename,
+            kind: undefined,
             size,
             stream: (0, node_fs_1.createReadStream)(temporaryArtifactPath),
         });
@@ -108,6 +138,10 @@ async function uploadArgentArtifactAsync(ctx, { deviceRunSessionId, toolsUrl, to
 async function downloadArgentArtifactToFileAsync({ artifact, toolsUrl, toolsAuthToken, destinationPath, }) {
     const response = await (0, node_fetch_1.default)(new URL(`/artifacts/${artifact.id}`, toolsUrl).toString(), {
         headers: toolsAuthToken ? { Authorization: `Bearer ${toolsAuthToken}` } : {},
+        signal: createTimeoutSignal({
+            signal: undefined,
+            timeoutMs: ARGENT_ARTIFACT_FETCH_TIMEOUT_MS,
+        }),
     });
     if (!response.ok) {
         throw new eas_build_job_1.SystemError(`Failed to download Argent artifact ${artifact.id}: ${response.status} ${response.statusText}`);
@@ -117,3 +151,41 @@ async function downloadArgentArtifactToFileAsync({ artifact, toolsUrl, toolsAuth
     }
     await (0, promises_2.pipeline)(response.body, (0, node_fs_1.createWriteStream)(destinationPath));
 }
+async function sleepUntilAbortedAsync(timeoutMs, signal) {
+    try {
+        await (0, promises_3.setTimeout)(timeoutMs, undefined, { signal });
+    }
+    catch (err) {
+        if (!signal.aborted) {
+            throw err;
+        }
+    }
+}
+function createTimeoutSignal({ signal, timeoutMs, }) {
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+}
+async function waitForPendingUploadsAsync({ pendingUploads, timeoutMs, logger, }) {
+    if (pendingUploads.size === 0) {
+        return;
+    }
+    logger.info(`Waiting for ${pendingUploads.size} Argent artifact upload(s) to finish.`);
+    let timeout;
+    try {
+        await Promise.race([
+            Promise.allSettled([...pendingUploads]),
+            new Promise((_resolve, reject) => {
+                timeout = setTimeout(() => {
+                    reject(new eas_build_job_1.SystemError(`Timed out after ${Math.round(timeoutMs / 1000)}s waiting for Argent artifact uploads.`, {
+                        trackingCode: 'SIMULATOR_ARTIFACT_SLOW_UPLOAD',
+                    }));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}

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

@@ -1,9 +1,11 @@
 import { CustomBuildContext } from '../../customBuildContext';
-export declare function uploadDeviceRunSessionArtifactAsync(ctx: CustomBuildContext, { deviceRunSessionId, artifactId, name, filename, size, stream, }: {
+export declare function uploadDeviceRunSessionArtifactAsync(ctx: CustomBuildContext, { deviceRunSessionId, artifactId, name, filename, kind, metadata, size, stream, }: {
     deviceRunSessionId: string;
     artifactId: string;
     name: string;
     filename: string;
+    kind: string | undefined;
+    metadata?: Record<string, unknown>;
     size: number;
     stream: NodeJS.ReadableStream;
 }): Promise<void>;

package/dist/steps/utils/deviceRunSessionArtifacts.js

@@ -52,12 +52,14 @@ const CREATE_DEVICE_RUN_SESSION_ARTIFACT_UPLOAD_SESSION_MUTATION = (0, gql_tada_
     }
   }
 `);
-async function uploadDeviceRunSessionArtifactAsync(ctx, { deviceRunSessionId, artifactId, name, filename, size, stream, }) {
+async function uploadDeviceRunSessionArtifactAsync(ctx, { deviceRunSessionId, artifactId, name, filename, kind, metadata, size, stream, }) {
     const uploadSession = await createDeviceRunSessionArtifactUploadSessionAsync(ctx, {
         deviceRunSessionId,
         artifactId,
         name,
         filename,
+        kind,
+        metadata,
         size,
     });
     const response = await (0, node_fetch_1.default)(uploadSession.url, {
@@ -69,13 +71,15 @@ async function uploadDeviceRunSessionArtifactAsync(ctx, { deviceRunSessionId, ar
         throw new eas_build_job_1.SystemError(`Failed to upload device run session artifact ${artifactId}: ${response.status} ${response.statusText}`, { cause: response });
     }
 }
-async function createDeviceRunSessionArtifactUploadSessionAsync(ctx, { deviceRunSessionId, artifactId, name, filename, size, }) {
+async function createDeviceRunSessionArtifactUploadSessionAsync(ctx, { deviceRunSessionId, artifactId, name, filename, kind, metadata, size, }) {
     const result = await ctx.graphqlClient
         .mutation(CREATE_DEVICE_RUN_SESSION_ARTIFACT_UPLOAD_SESSION_MUTATION, {
         deviceRunSessionId,
         input: {
             name,
             filename,
+            ...(kind !== undefined ? { kind } : {}),
+            ...(metadata !== undefined ? { metadata } : {}),
             size,
         },
     })

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

@@ -15,6 +15,12 @@ export declare function selectXcodeDeveloperDirectoryAsync({ env, logger, }: {
     env: BuildStepEnv;
     logger: bunyan;
 }): Promise<void>;
+export declare function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, signal, }: {
+    ctx: CustomBuildContext;
+    deviceRunSessionId: string;
+    logger: bunyan;
+    signal?: AbortSignal;
+}): Promise<void>;
 /**
  * Translate Cloudflare ICE servers into serve-sim CLI flags: `--stun-url` (the
  * credential-less entries) and `--turn-url`/`--turn-username`/`--turn-credential`
@@ -42,6 +48,8 @@ export declare function uploadRemoteSessionConfigAsync({ ctx, deviceRunSessionId
     logger: bunyan;
 }): Promise<void>;
 export type DetachedProcessHandle = {
+    /** PID of the directly spawned process, if the OS assigned one. */
+    pid: number | undefined;
     getOutput: () => string;
 };
 export declare function spawnDetached({ command, args, cwd, env, }: {

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -40,6 +40,7 @@ exports.getDeviceRunSessionIdOrThrow = getDeviceRunSessionIdOrThrow;
 exports.getNgrokTunnelDomainOrThrow = getNgrokTunnelDomainOrThrow;
 exports.getNgrokAuthtokenOrThrow = getNgrokAuthtokenOrThrow;
 exports.selectXcodeDeveloperDirectoryAsync = selectXcodeDeveloperDirectoryAsync;
+exports.waitForDeviceRunSessionStoppedAsync = waitForDeviceRunSessionStoppedAsync;
 exports.turnIceServersToServeSimArgs = turnIceServersToServeSimArgs;
 exports.fetchServeSimTurnArgsAsync = fetchServeSimTurnArgsAsync;
 exports.uploadRemoteSessionConfigAsync = uploadRemoteSessionConfigAsync;
@@ -56,6 +57,7 @@ const nullthrows_1 = __importDefault(require("nullthrows"));
 const zod_1 = require("zod");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = require("node:timers/promises");
 const sentry_1 = require("../../sentry");
 const retry_1 = require("../../utils/retry");
 const turtleFetch_1 = require("../../utils/turtleFetch");
@@ -73,6 +75,17 @@ const START_DEVICE_RUN_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
     }
   }
 `);
+const DEVICE_RUN_SESSION_STATUS_QUERY = (0, gql_tada_1.graphql)(`
+  query DeviceRunSessionStatus($deviceRunSessionId: ID!) {
+    deviceRunSessions {
+      byId(deviceRunSessionId: $deviceRunSessionId) {
+        id
+        status
+      }
+    }
+  }
+`);
+const DEVICE_RUN_SESSION_STATUS_POLL_INTERVAL_MS = 5_000;
 function getDeviceRunSessionIdOrThrow(env) {
     const deviceRunSessionId = env.DEVICE_RUN_SESSION_ID;
     if (!deviceRunSessionId) {
@@ -117,6 +130,54 @@ async function selectXcodeDeveloperDirectoryAsync({ env, logger, }) {
         stdio: ['ignore', 'pipe', 'pipe'],
     });
 }
+async function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, signal, }) {
+    logger.info(`Remote session is live. Polling device run session ${deviceRunSessionId} until it is stopped.`);
+    let pollErrorCount = 0;
+    while (!signal?.aborted) {
+        try {
+            const result = await ctx.graphqlClient
+                .query(DEVICE_RUN_SESSION_STATUS_QUERY, { deviceRunSessionId })
+                .toPromise();
+            if (result.error) {
+                throw result.error;
+            }
+            const status = result.data?.deviceRunSessions?.byId?.status;
+            if (!status) {
+                throw new Error(`Device run session ${deviceRunSessionId} status response was missing.`);
+            }
+            pollErrorCount = 0;
+            if (status === 'STOPPED') {
+                logger.info(`Device run session ${deviceRunSessionId} was stopped.`);
+                return;
+            }
+            if (status === 'ERRORED') {
+                throw new eas_build_job_1.SystemError(`Device run session ${deviceRunSessionId} errored.`);
+            }
+        }
+        catch (err) {
+            if (err instanceof eas_build_job_1.SystemError) {
+                throw err;
+            }
+            const error = err instanceof Error ? err : new Error(String(err));
+            pollErrorCount += 1;
+            if (pollErrorCount === 1 || pollErrorCount % 5 === 0) {
+                sentry_1.Sentry.capture('Could not poll device run session status', error, { level: 'warning' });
+                logger.warn({ err: error, failedStatusPollCount: pollErrorCount }, 'Could not poll device run session status; will retry.');
+            }
+        }
+        await sleepUntilAbortedAsync(DEVICE_RUN_SESSION_STATUS_POLL_INTERVAL_MS, signal);
+    }
+}
+async function sleepUntilAbortedAsync(timeoutMs, signal) {
+    try {
+        await (0, promises_1.setTimeout)(timeoutMs, undefined, signal ? { signal } : undefined);
+    }
+    catch (err) {
+        if (!signal?.aborted) {
+            throw err;
+        }
+    }
+}
 const TurnIceServersResponseSchema = zod_1.z.object({
     data: zod_1.z.object({
         iceServers: TurnIceServersSchema,
@@ -204,7 +265,7 @@ function spawnDetached({ command, args, cwd, env, }) {
     };
     promise.child.stdout?.on('data', appendChunk);
     promise.child.stderr?.on('data', appendChunk);
-    return { getOutput: () => output };
+    return { pid: promise.child.pid, getOutput: () => output };
 }
 async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, timeoutMs, }) {
     logger.info('Launching serve-sim with tunnel.');

package/dist/utils/AndroidEmulatorUtils.js

@@ -240,6 +240,9 @@ var AndroidEmulatorUtils;
             await emulatorPromise;
         }
         emulatorPromise.child.unref();
+        // The emulator is detached and managed through adb. Observe its process promise
+        // immediately so expected exits during retry cleanup do not become unhandled rejections.
+        void (0, results_1.asyncResult)(emulatorPromise);
         const serialId = await (0, retry_1.retryAsync)(async () => {
             const serialId = await getSerialIdAsync({ deviceName, env });
             (0, assert_1.default)(serialId, `Failed to configure emulator (${serialId}): emulator with required ID not found.`);

package/dist/utils/IosSimulatorUtils.d.ts

@@ -24,6 +24,7 @@ export declare namespace IosSimulatorUtils {
     };
     type SimulatorDevice = XcrunSimctlDevice & {
         runtime: string;
+        runtimeDisplayName: string;
         displayName: string;
     };
     export function getAvailableDevicesAsync({ env, filter, }: {

package/dist/utils/IosSimulatorUtils.js

@@ -21,6 +21,7 @@ var IosSimulatorUtils;
             allAvailableDevices.push(...devices.map(device => ({
                 ...device,
                 runtime,
+                runtimeDisplayName: formatRuntimeDisplayName(runtime),
                 displayName: `${device.name} (${device.udid}) on ${runtime}`,
             })));
         }
@@ -118,8 +119,30 @@ var IosSimulatorUtils;
     }
     IosSimulatorUtils.waitForReadyAsync = waitForReadyAsync;
     async function disableApsdAsync({ udid, env, }) {
-        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'spawn', udid, 'launchctl', 'disable', 'system/com.apple.apsd'], { env });
-        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'spawn', udid, 'launchctl', 'bootout', 'system/com.apple.apsd'], { env });
+        const launchctlDomains = ['user/foreground', 'system'];
+        let lastError;
+        for (const domain of launchctlDomains) {
+            const service = `${domain}/com.apple.apsd`;
+            try {
+                await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'spawn', udid, 'launchctl', 'disable', service], { env });
+                try {
+                    await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'spawn', udid, 'launchctl', 'bootout', service], {
+                        env,
+                    });
+                }
+                catch (err) {
+                    // bootout can fail when apsd is already gone; verify the service state below.
+                    lastError = err;
+                }
+                if (!(await isLaunchctlServiceLoadedAsync({ udid, env, serviceLabel: 'com.apple.apsd' }))) {
+                    return;
+                }
+            }
+            catch (err) {
+                lastError = err;
+            }
+        }
+        throw lastError ?? new eas_build_job_1.SystemError('Unable to disable apsd in the Simulator.');
     }
     IosSimulatorUtils.disableApsdAsync = disableApsdAsync;
     async function collectLogsAsync({ deviceIdentifier, env, }) {
@@ -196,6 +219,22 @@ var IosSimulatorUtils;
     }
     IosSimulatorUtils.isDataMigratorProcessRunning = isDataMigratorProcessRunning;
 })(IosSimulatorUtils || (exports.IosSimulatorUtils = IosSimulatorUtils = {}));
+function formatRuntimeDisplayName(runtimeIdentifier) {
+    const match = /^com\.apple\.CoreSimulator\.SimRuntime\.([^-]+)-(.+)$/.exec(runtimeIdentifier);
+    return match ? `${match[1]} ${match[2].replaceAll('-', '.')}` : runtimeIdentifier;
+}
+async function isLaunchctlServiceLoadedAsync({ udid, env, serviceLabel, }) {
+    try {
+        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'spawn', udid, 'launchctl', 'list', serviceLabel], { env });
+        return true;
+    }
+    catch (err) {
+        if (err instanceof Error && 'status' in err && err.status === 113) {
+            return false;
+        }
+        throw err;
+    }
+}
 function parseUdidFromBootstatusStdout(stdout) {
     const matches = stdout.match(/^Monitoring boot status for .+ \((.+)\)\.$/m);
     if (!matches) {

package/dist/utils/expoUpdatesEmbedded.js

@@ -20,6 +20,10 @@ async function uploadEmbeddedBundleAsync(ctx) {
         ctx.markBuildPhaseSkipped();
         return;
     }
+    if (ctx.job.developmentClient) {
+        ctx.markBuildPhaseSkipped();
+        return;
+    }
     const { platform } = ctx.job;
     if (platform === eas_build_job_1.Platform.IOS && ctx.job.simulator) {
         ctx.markBuildPhaseSkipped();

package/dist/utils/processes.d.ts

@@ -1 +1,2 @@
 export declare function getParentAndDescendantProcessPidsAsync(ppid: number): Promise<number[]>;
+export declare function isProcessDescendantOfAsync(pid: number, ancestorPid: number): Promise<boolean>;

package/dist/utils/processes.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getParentAndDescendantProcessPidsAsync = getParentAndDescendantProcessPidsAsync;
+exports.isProcessDescendantOfAsync = isProcessDescendantOfAsync;
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 async function getChildrenPidsAsync(parentPids) {
     try {
@@ -35,3 +36,25 @@ async function getParentAndDescendantProcessPidsAsync(ppid) {
     }
     return [...children];
 }
+async function isProcessDescendantOfAsync(pid, ancestorPid) {
+    let currentPid = pid;
+    while (currentPid > 0) {
+        if (currentPid === ancestorPid) {
+            return true;
+        }
+        try {
+            const result = await (0, turtle_spawn_1.default)('ps', ['-p', String(currentPid), '-o', 'ppid='], {
+                stdio: 'pipe',
+            });
+            const parentPid = Number(result.stdout.toString().trim());
+            if (!Number.isInteger(parentPid) || parentPid <= 0 || parentPid === currentPid) {
+                return false;
+            }
+            currentPid = parentPid;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "20.5.1",
+  "version": "21.0.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -23,6 +23,7 @@
     "watch": "tsc --watch --preserveWatchOutput",
     "prebuild": "yarn gql",
     "build": "tsc",
+    "build:record-sim": "mkdir -p bin && record_sim_bin_path=$(swift build -c release --package-path resources/record-sim --build-path resources/record-sim/.build --show-bin-path) && swift build -c release --package-path resources/record-sim --build-path resources/record-sim/.build && cp \"$record_sim_bin_path/record-sim\" bin/record-sim && chmod +x bin/record-sim",
     "typecheck": "tsc",
     "prepack": "rimraf dist \"*.tsbuildinfo\" && yarn gql && tsc -p tsconfig.build.json",
     "jest-unit": "jest --config jest/unit-config.ts",
@@ -37,17 +38,17 @@
   "dependencies": {
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
-    "@expo/downloader": "20.0.0",
-    "@expo/eas-build-job": "20.5.1",
+    "@expo/downloader": "21.0.0",
+    "@expo/eas-build-job": "21.0.0",
     "@expo/env": "^0.4.0",
-    "@expo/logger": "20.0.0",
+    "@expo/logger": "21.0.0",
     "@expo/package-manager": "1.9.10",
     "@expo/plist": "^0.2.0",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "20.5.1",
-    "@expo/template-file": "20.0.0",
-    "@expo/turtle-spawn": "20.0.0",
+    "@expo/steps": "21.0.0",
+    "@expo/template-file": "21.0.0",
+    "@expo/turtle-spawn": "21.0.0",
     "@expo/xcpretty": "^4.3.1",
     "@google-cloud/storage": "^7.11.2",
     "@ngrok/ngrok": "1.7.0",
@@ -100,5 +101,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "cd47185f29446299b7682d52cd917eb9a01038e7"
+  "gitHead": "c72cee372f2d45a252acb014493311de85776497"
 }

package/resources/record-sim/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+
+import PackageDescription
+
+let package = Package(
+    name: "record-sim",
+    platforms: [
+        .macOS(.v14),
+    ],
+    products: [
+        .library(name: "RecordSim", targets: ["RecordSim"]),
+        .executable(name: "record-sim", targets: ["record-sim"]),
+    ],
+    targets: [
+        .target(
+            name: "RecordSim",
+            linkerSettings: [
+                .linkedFramework("AVFoundation"),
+                .linkedFramework("CoreGraphics"),
+                .linkedFramework("CoreMedia"),
+                .linkedFramework("CoreVideo"),
+                .linkedFramework("IOSurface"),
+                .linkedFramework("UniformTypeIdentifiers"),
+            ]
+        ),
+        .executableTarget(name: "record-sim", dependencies: ["RecordSim"]),
+    ]
+)

package/resources/record-sim/README.md

@@ -0,0 +1,79 @@
+# RecordSim
+
+Small Swift library for non-exclusive iOS Simulator screen recording.
+
+It implements one recording path:
+
+1. Listen to SimRenderServer framebuffer callbacks.
+2. Copy the live `IOSurface` immediately into an owned `CVPixelBuffer`.
+3. Feed one continuous `AVAssetWriter`.
+4. Emit Apple HLS/CMAF-style fragmented MP4 segments.
+
+The output is suitable for uploading while recording. `session.json` contains
+the ordered segment metadata needed to build a playlist later.
+
+## Output
+
+```text
+session/
+  init.mp4
+  session.json
+  segments/
+    segment-000000.m4s
+    segment-000001.m4s
+```
+
+`init.mp4` is the fMP4 initialization segment. Individual `.m4s` files are not
+standalone MP4 files. `session.json` stores the wall-clock timestamp for the
+first video frame plus the metadata needed to build a playlist: HLS version,
+target duration, media sequence, `initSegment`, and the ordered `segments` array
+with file path and duration for each media segment.
+
+## CLI
+
+```bash
+swift run record-sim \
+  --udid <BOOTED_SIMULATOR_UDID> \
+  --output /tmp/sim-recording \
+  --segment-duration 120 \
+  --fps 30 \
+  --bitrate 30000000 \
+  --codec h264
+```
+
+For sparse 2h sessions, `--segment-duration 120` is a reasonable default: about
+60 media objects plus the init segment. The recorder appends a single duplicate
+hold frame near each segment boundary when the simulator is idle, so long idle
+periods still produce uploadable segments without encoding idle frames at 60fps.
+Use `--segment-duration 0` to write one continuous `recording.mp4` instead of
+`init.mp4` plus media segments.
+
+Frame timestamps use monotonic host time, not wall-clock time. The recorder also
+probes the framebuffer seed once per second; if the surface changes without
+callbacks for 5 seconds, it captures that frame and rewires the private callback
+registration.
+
+## Library
+
+```swift
+let recorder = SimulatorRecorder(
+  configuration: SimulatorRecordingConfiguration(
+    deviceUDID: udid,
+    outputDirectory: sessionDirectory,
+    segmentDuration: 120
+  )
+)
+
+recorder.onSegment = { segment in
+  // Enqueue upload of segment.url.
+}
+
+try recorder.start()
+try recorder.waitUntilFirstFrame()
+// ...
+let manifest = try recorder.stop()
+```
+
+`session.json` contains the precise wall-clock time for video PTS zero. In
+segmented mode it also contains the init segment and ordered media segment
+file/duration entries; in single-file mode it points at `recording.mp4`.