@devicecloud.dev/dcd 5.5.0 → 5.6.0-beta.4

package/dist/services/results-polling.service.d.ts

@@ -6,6 +6,14 @@ export declare class RunFailedError extends Error {
     result: PollingResult;
     constructor(result: PollingResult);
 }
+/**
+ * The `dcd login` session behind a poll expired and only a new login can fix
+ * it, so the poll stops at once instead of spending its retry budget — meant
+ * for network blips — on a failure that can't clear.
+ */
+export declare class PollingAuthError extends Error {
+    constructor(message: string);
+}
 export interface PollingOptions {
     auth: AuthContext;
     apiUrl: string;
@@ -45,9 +53,29 @@ export declare function deviceFromResultRow(r: {
     config?: unknown;
     simulator_name?: string | null;
 }): TestDevice | undefined;
+/**
+ * Was this row cancelled because a newer run from the same CI context
+ * replaced it (`dcd cloud --cancel-previous`)?
+ *
+ * Read through a structural cast for the same reason deviceFromResultRow
+ * does: the committed generated types are regenerated wholesale from dev's
+ * swagger and lag the API, and this must work against an API that already
+ * sends the field.
+ */
+export declare function isSupersededRow(r: unknown): boolean;
+/** The upload that superseded this run, for the console link. */
+export declare function supersedingUploadId(results: unknown[]): string | undefined;
+/**
+ * The superseding run's console link, derived from this run's.
+ *
+ * The `result` parameter deep-links a single test, and that id belongs to
+ * THIS upload — carrying it over would point at a result the newer upload
+ * does not contain. Swap the upload id and drop it.
+ */
+export declare function supersedingConsoleUrl(consoleUrl: string, uploadId: string, supersededBy: string): string;
 export interface PollingResult {
     consoleUrl: string;
-    status: 'FAILED' | 'PASSED';
+    status: 'FAILED' | 'PASSED' | 'SUPERSEDED';
     tests: Array<{
         /** Device this result ran on (present when the API reports it). */
         device?: TestDevice;
@@ -95,6 +123,19 @@ export declare class ResultsPollingService {
      * @returns Promise resolving to test results
      */
     private fetchAndLogResults;
+    /**
+     * Swap in a fresh `dcd login` token when the current one is about to
+     * expire, and hand it to the realtime socket too; API-key auth comes back
+     * as-is. A transient refresh failure is thrown as-is, to be retried like
+     * any failed poll; one only `dcd login` can fix becomes a PollingAuthError.
+     * @param auth The credential the previous poll used
+     * @param uploadId Upload being polled, for the reconnect hint
+     * @param subscription Realtime subscription to pass a new token to
+     * @param debug Whether debug logging is enabled
+     * @param logger Optional logger function
+     * @returns The credential for the next poll
+     */
+    private refreshPollingAuth;
     private filterLatestResults;
     /**
      * Handle completed tests and return final result

package/dist/services/results-polling.service.js

@@ -2,6 +2,7 @@ import * as path from 'node:path';
 import { ApiGateway } from '../gateways/api-gateway.js';
 import { RealtimeResultsGateway, } from '../gateways/realtime-gateway.js';
 import { formatDurationSeconds } from '../methods.js';
+import { isDefinitiveAuthFailure, refreshAuth } from '../utils/auth.js';
 import { checkInternetConnectivity } from '../utils/connectivity.js';
 import { isCI } from '../utils/ci.js';
 import { ux } from '../utils/progress.js';
@@ -18,6 +19,17 @@ export class RunFailedError extends Error {
         this.name = 'RunFailedError';
     }
 }
+/**
+ * The `dcd login` session behind a poll expired and only a new login can fix
+ * it, so the poll stops at once instead of spending its retry budget — meant
+ * for network blips — on a failure that can't clear.
+ */
+export class PollingAuthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PollingAuthError';
+    }
+}
 /**
  * Structured device for a result row. Prefers the friendly deviceName/osVersion
  * the per-flow targeting / matrix fan-out stamps onto each result's config
@@ -38,6 +50,45 @@ export function deviceFromResultRow(r) {
         googlePlay: sim ? /(_PLAY|-play)$/.test(sim) : undefined,
     };
 }
+/**
+ * Was this row cancelled because a newer run from the same CI context
+ * replaced it (`dcd cloud --cancel-previous`)?
+ *
+ * Read through a structural cast for the same reason deviceFromResultRow
+ * does: the committed generated types are regenerated wholesale from dev's
+ * swagger and lag the API, and this must work against an API that already
+ * sends the field.
+ */
+export function isSupersededRow(r) {
+    const reason = r
+        ?.cancellation_reason;
+    return typeof reason === 'string' && reason.startsWith('superseded_by:');
+}
+/** The upload that superseded this run, for the console link. */
+export function supersedingUploadId(results) {
+    for (const r of results) {
+        const reason = r
+            ?.cancellation_reason;
+        if (typeof reason === 'string' && reason.startsWith('superseded_by:')) {
+            return reason.slice('superseded_by:'.length) || undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * The superseding run's console link, derived from this run's.
+ *
+ * The `result` parameter deep-links a single test, and that id belongs to
+ * THIS upload — carrying it over would point at a result the newer upload
+ * does not contain. Swap the upload id and drop it.
+ */
+export function supersedingConsoleUrl(consoleUrl, uploadId, supersededBy) {
+    return consoleUrl
+        .replace(uploadId, supersededBy)
+        .replace(/&result=[^&]*/, '')
+        .replace(/\?result=[^&]*&/, '?')
+        .replace(/\?result=[^&]*$/, '');
+}
 /**
  * Service for polling test results from the API
  */
@@ -76,7 +127,10 @@ export class ResultsPollingService {
         }
     }
     async pollLoop(options, testMetadata) {
-        const { apiUrl, auth, uploadId, consoleUrl, quiet = false, json = false, debug = false, logger } = options;
+        const { apiUrl, uploadId, consoleUrl, quiet = false, json = false, debug = false, logger } = options;
+        // Re-checked before every poll: a run can outlast a `dcd login` access
+        // token (about an hour). API-key auth passes through unchanged.
+        let { auth } = options;
         this.initializePollingDisplay(json, logger);
         let sequentialPollFailures = 0;
         const pollIntervalMs = auth.mode === 'bearer'
@@ -174,6 +228,7 @@ export class ResultsPollingService {
                 try {
                     nextPollAt = null;
                     renderStatus();
+                    auth = await this.refreshPollingAuth(auth, uploadId, subscription, debug, logger);
                     const updatedResults = await this.fetchAndLogResults(apiUrl, auth, uploadId, debug, logger);
                     const { summary } = this.calculateStatusSummary(updatedResults);
                     if (!json) {
@@ -199,8 +254,9 @@ export class ResultsPollingService {
                     await waitForNextPoll(pollIntervalMs);
                 }
                 catch (error) {
-                    // Re-throw RunFailedError immediately (test failures, not polling errors)
-                    if (error instanceof RunFailedError) {
+                    // Re-throw RunFailedError immediately (test failures, not polling
+                    // errors), and an expired login no retry can fix.
+                    if (error instanceof RunFailedError || error instanceof PollingAuthError) {
                         throw error;
                     }
                     sequentialPollFailures++;
@@ -226,13 +282,23 @@ export class ResultsPollingService {
     }
     buildPollingResult(results, uploadId, consoleUrl, testMetadata) {
         const resultsWithoutEarlierTries = this.filterLatestResults(results);
+        // ANY superseded row settles the whole verdict, even alongside a test
+        // that had genuinely failed before the newer run replaced this one: this
+        // run no longer speaks for the commit, so failing the build on its behalf
+        // is wrong. Actions reaches the same conclusion — a cancelled run's
+        // conclusion is `cancelled`, whatever had already failed inside it. The
+        // failure is still printed and still in `tests[]`; only the exit code
+        // changes.
+        const superseded = resultsWithoutEarlierTries.some(isSupersededRow);
         return {
             consoleUrl,
             // Anything other than an explicit pass (CANCELLED, ERROR, a status we
             // don't know about yet) must fail the run — this gates CI exit codes.
-            status: resultsWithoutEarlierTries.every((result) => result.status === 'PASSED')
-                ? 'PASSED'
-                : 'FAILED',
+            status: superseded
+                ? 'SUPERSEDED'
+                : resultsWithoutEarlierTries.every((result) => result.status === 'PASSED')
+                    ? 'PASSED'
+                    : 'FAILED',
             tests: resultsWithoutEarlierTries.map((r) => ({
                 // r carries config/simulator_name at runtime; the committed generated
                 // types lag the API (regenerated wholesale from dev's swagger), so read
@@ -259,8 +325,12 @@ export class ResultsPollingService {
         const pending = statusCounts.PENDING || 0;
         const queued = statusCounts.QUEUED || 0;
         const running = statusCounts.RUNNING || 0;
+        // CANCELLED is terminal, so it counts as completed. Without it a
+        // cancelled or superseded run's footer sticks at "8/12 completed"
+        // forever, having already stopped polling.
+        const cancelled = statusCounts.CANCELLED || 0;
         const total = results.length;
-        const completed = passed + failed;
+        const completed = passed + failed + cancelled;
         const summary = formatTestSummary({
             completed,
             failed,
@@ -346,6 +416,41 @@ export class ResultsPollingService {
         }
         return updatedResults;
     }
+    /**
+     * Swap in a fresh `dcd login` token when the current one is about to
+     * expire, and hand it to the realtime socket too; API-key auth comes back
+     * as-is. A transient refresh failure is thrown as-is, to be retried like
+     * any failed poll; one only `dcd login` can fix becomes a PollingAuthError.
+     * @param auth The credential the previous poll used
+     * @param uploadId Upload being polled, for the reconnect hint
+     * @param subscription Realtime subscription to pass a new token to
+     * @param debug Whether debug logging is enabled
+     * @param logger Optional logger function
+     * @returns The credential for the next poll
+     */
+    async refreshPollingAuth(auth, uploadId, subscription, debug, logger) {
+        let next;
+        try {
+            next = await refreshAuth(auth);
+        }
+        catch (error) {
+            if (isDefinitiveAuthFailure(error)) {
+                const reason = error instanceof Error ? error.message : String(error);
+                throw new PollingAuthError(`Your dcd login session expired and could not be refreshed: ${reason}\n\n` +
+                    `The test is still running in the cloud. Run \`dcd login\`, then reconnect with:\n  dcd status --upload-id ${uploadId}`);
+            }
+            throw error;
+        }
+        if (next !== auth) {
+            if (debug && logger) {
+                logger('[DEBUG] Refreshed the dcd login session for polling');
+            }
+            if (next.accessToken && next.accessToken !== auth.accessToken) {
+                subscription?.updateAccessToken(next.accessToken);
+            }
+        }
+        return next;
+    }
     filterLatestResults(results) {
         // Resolve each row to the root of its retry chain (a retry's `retry_of`
         // may point at the previous retry rather than the original attempt), then
@@ -386,6 +491,27 @@ export class ResultsPollingService {
         }
         this.displayFinalResults(updatedResults, consoleUrl, json, logger);
         const output = this.buildPollingResult(updatedResults, uploadId, consoleUrl, testMetadata);
+        if (output.status === 'SUPERSEDED') {
+            // Exit 0: a newer run of the same CI context replaced this one, so
+            // failing the build here would fail it for work nobody is waiting on.
+            // Falls through to the success return below — RunFailedError, and with
+            // it the exit code 2 in `dcd cloud`, is never reached.
+            if (logger && !json) {
+                const newer = supersedingUploadId(updatedResults);
+                logger('\n');
+                logger(ui.warn('Run superseded by a newer run from the same CI context — exiting 0'));
+                if (newer) {
+                    logger(ui.branch(ui.fields([
+                        [
+                            'superseded by',
+                            colors.url(supersedingConsoleUrl(consoleUrl, uploadId, newer)),
+                        ],
+                    ])));
+                }
+                logger('\n');
+            }
+            return output;
+        }
         if (output.status === 'FAILED') {
             if (debug && logger) {
                 logger(`[DEBUG] Some tests failed, returning failed status`);

package/dist/services/test-submission.service.d.ts

@@ -6,12 +6,30 @@ export interface TestSubmissionConfig {
     androidNoSnapshot?: boolean;
     apiUrl?: string;
     appBinaryId: string;
+    /**
+     * Platform of the app binary, when the CLI can tell from a local file
+     * (.apk → android; .app / .zip / Expo .tar.gz → ios). Unknown for
+     * --app-binary-id, which falls back to the device flags.
+     */
+    appPlatform?: 'android' | 'ios';
+    /**
+     * Ask the API to cancel the still-queued tests of the previous run from
+     * the same CI context. Sent as its own field rather than inside `config`,
+     * which is stamped onto every result row and shipped to the runner — this
+     * is a one-off submission directive, not run configuration.
+     */
+    cancelPrevious?: boolean;
     cliVersion: string;
     commonRoot: string;
     continueOnFailure?: boolean;
     debug?: boolean;
     deviceLocale?: string;
     deviceMatrix?: DeviceMatrixConfig[];
+    /**
+     * --disable-animations as given on the command line: true / false when the
+     * flag (or --no-disable-animations) was passed, undefined when it wasn't —
+     * only then does the workspace config's per-platform value apply.
+     */
     disableAnimations?: boolean;
     /**
      * Encrypt the flow zip and env vars before upload (#1151/#1152), each with its

package/dist/services/test-submission.service.js

@@ -20,8 +20,8 @@ export class TestSubmissionService {
      * @returns The flow zip buffer, its SHA-256, and the string-encoded fields
      */
     async buildTestPayload(config) {
-        const { apiUrl, appBinaryId, encrypt = false, flowFile, executionPlan, commonRoot, cliVersion, env = [], metadata = [], googlePlay = false, androidApiLevel, androidDevice, androidNoSnapshot, iOSVersion, iOSDevice, name, runnerType, maestroVersion, deviceLocale, orientation, retry, continueOnFailure = true, renderEngine, report, showCrosshairs, maestroChromeOnboarding, raw, disableAnimations, deviceMatrix, debug = false, logger, } = config;
-        const { allExcludeTags, allIncludeTags, flowMetadata, flowOverrides, flowsToRun: testFileNames, referencedFiles, sequence, workspaceConfig, } = executionPlan;
+        const { apiUrl, appBinaryId, appPlatform, encrypt = false, flowFile, executionPlan, commonRoot, cliVersion, env = [], metadata = [], cancelPrevious = false, googlePlay = false, androidApiLevel, androidDevice, androidNoSnapshot, iOSVersion, iOSDevice, name, runnerType, maestroVersion, deviceLocale, orientation, retry, continueOnFailure = true, renderEngine, report, showCrosshairs, maestroChromeOnboarding, raw, disableAnimations, deviceMatrix, debug = false, logger, } = config;
+        const { allExcludeTags, allIncludeTags, flowMetadata, flowOverrides, flowsToRun: testFileNames, includedFiles = [], referencedFiles, sequence, workspaceConfig, } = executionPlan;
         const { flows: sequentialFlows = [] } = sequence ?? {};
         const envObject = this.parseKeyValuePairs(env);
         const metadataObject = this.parseKeyValuePairs(metadata);
@@ -42,6 +42,17 @@ export class TestSubmissionService {
                 }
             }
         }
+        // Logged separately from referencedFiles: these come from config.yaml's
+        // `includedPaths` rather than from a flow command, and they can raise the
+        // common root (see computeCommonRoot) — which shows up here as every flow
+        // key gaining a leading directory segment.
+        if (includedFiles.length > 0) {
+            this.logDebug(debug, logger, `[DEBUG] Uploading ${includedFiles.length} file(s) from \`includedPaths\`:`);
+            for (const file of includedFiles) {
+                const normalizedPath = this.normalizeFilePath(file, commonRoot);
+                this.logDebug(debug, logger, `[DEBUG]   - ${normalizedPath}`);
+            }
+        }
         this.logDebug(debug, logger, `[DEBUG] Compressing files from path: ${flowFile}`);
         const plaintextZip = await compressFilesFromRelativePath(flowFile?.endsWith('.yaml') || flowFile?.endsWith('.yml')
             ? path.dirname(flowFile)
@@ -50,6 +61,7 @@ export class TestSubmissionService {
                 ...referencedFiles,
                 ...testFileNames,
                 ...sequentialFlows,
+                ...includedFiles,
             ]),
         ], commonRoot);
         this.logDebug(debug, logger, `[DEBUG] Compressed file size: ${plaintextZip.length} bytes`);
@@ -108,18 +120,25 @@ export class TestSubmissionService {
             fields.deviceMatrix = JSON.stringify(deviceMatrix);
         }
         // Platform used only to pick which workspace-config disableAnimations flag
-        // applies. A device matrix is single-platform; its first cell decides. Fall
-        // back to the scalar iOS flags for single-device submissions.
+        // applies. The binary decides when the CLI knows it — otherwise an iOS run
+        // without --ios-device/--ios-version read the android block. For an
+        // --app-binary-id, a device matrix (single-platform; its first cell
+        // decides) or the scalar iOS flags are the best evidence left.
         const matrixPlatform = deviceMatrix && deviceMatrix.length > 0
             ? 'iOSDevice' in deviceMatrix[0]
                 ? 'ios'
                 : 'android'
             : undefined;
-        const targetPlatform = matrixPlatform ?? (iOSDevice || iOSVersion ? 'ios' : 'android');
+        const targetPlatform = appPlatform ??
+            matrixPlatform ??
+            (iOSDevice || iOSVersion ? 'ios' : 'android');
         const configYamlDisableAnimations = targetPlatform === 'ios'
             ? Boolean(workspaceConfig?.platform?.ios?.disableAnimations)
             : Boolean(workspaceConfig?.platform?.android?.disableAnimations);
-        const effectiveDisableAnimations = disableAnimations || configYamlDisableAnimations;
+        // An explicit --disable-animations / --no-disable-animations wins over
+        // config.yaml; previously `flag || config` meant the flag could only ever
+        // turn animations off, never keep them on against the config.
+        const effectiveDisableAnimations = disableAnimations ?? configYamlDisableAnimations;
         const configPayload = {
             allExcludeTags,
             allIncludeTags,
@@ -144,6 +163,11 @@ export class TestSubmissionService {
             fields.metadata = JSON.stringify(metadataPayload);
             this.logDebug(debug, logger, `[DEBUG] Sending metadata to API: ${JSON.stringify(metadataPayload)}`);
         }
+        // Only sent when asked for, so every other submission's wire shape is
+        // unchanged and the flag is simply ignored by an older API.
+        if (cancelPrevious) {
+            fields.cancelPrevious = 'true';
+        }
         this.setOptionalFields(fields, {
             androidApiLevel,
             androidDevice,

package/dist/services/workspace-config.schema.d.ts

@@ -12,6 +12,7 @@ export declare const WorkspaceConfigSchema: z.ZodObject<{
         flowsOrder: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>>;
     flows: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    includedPaths: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
     includeTags: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodArray<z.ZodString>, unknown>>>;
     local: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         deterministicOrder: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;

package/dist/services/workspace-config.schema.js

@@ -42,6 +42,7 @@ export const WorkspaceConfigSchema = z.looseObject({
     excludeTags: tagList.nullish(),
     executionOrder: ExecutionOrderSchema.nullish(),
     flows: z.array(z.string()).nullish(),
+    includedPaths: z.array(z.string()).nullish(),
     includeTags: tagList.nullish(),
     local: z
         .looseObject({ deterministicOrder: z.boolean().nullish() })
@@ -80,10 +81,15 @@ export const WORKSPACE_CONFIG_KEYS = new Set(Object.keys(WorkspaceConfigSchema.s
  * Near-misses that aren't just a casing slip on a real key. Keyed lowercase.
  */
 const KEY_ALIASES = {
+    assets: 'includedPaths',
     continueonfailure: 'executionOrder.continueOnFailure',
     excludetag: 'excludeTags',
+    files: 'includedPaths',
     floworder: 'executionOrder.flowsOrder',
     flowsorder: 'executionOrder.flowsOrder',
+    includedpath: 'includedPaths',
+    includefiles: 'includedPaths',
+    includepaths: 'includedPaths',
     includetag: 'includeTags',
     tags: 'includeTags / excludeTags',
 };

package/dist/types/domain/auth.types.d.ts

@@ -13,6 +13,12 @@ export interface AuthContext {
     accessToken?: string;
     /** Environment the session belongs to — present when mode === 'bearer'. */
     env?: DcdEnvName;
+    /**
+     * Unix epoch seconds at which `accessToken` expires — present when
+     * mode === 'bearer'. Long-lived callers check it (utils/auth.ts
+     * isAuthExpiring / refreshAuth) because the headers below stop working then.
+     */
+    expiresAt?: number;
     /** Present when mode === 'bearer'. */
     orgId?: string;
     /** Present when mode === 'bearer'. */

package/dist/types/domain/device.types.d.ts

@@ -1,17 +1,31 @@
 /**
  * Device type definitions - should be kept in sync with API
- * @see /Users/riglar/repos/dcd/api/src/common/types/device.types.ts
+ * @see dcd/api/src/common/types/device.types.ts
+ *
+ * These drive the `--ios-device` / `--ios-version` / `--android-device` /
+ * `--android-api-level` help text and nothing else: validation runs against
+ * the live compatibility payload (device-validation.service.ts). A value the
+ * API has dropped gets a "not supported" error listing what it offers now, and
+ * one it has added is accepted even if it is missing here — so keeping these
+ * lists current only improves the help text; it never gates a run.
+ *
+ * `iphone-14-pro` and `iphone-15-pro` were listed here but have never existed
+ * in the API enum; removed 2026-09-21 rather than carried forward.
  */
 export declare enum EiOSDevices {
     'ipad-pro-6th-gen' = "ipad-pro-6th-gen",
+    'ipad-pro-m5-11' = "ipad-pro-m5-11",
+    'ipad-pro-m5-13' = "ipad-pro-m5-13",
     'iphone-14' = "iphone-14",
-    'iphone-14-pro' = "iphone-14-pro",
     'iphone-15' = "iphone-15",
-    'iphone-15-pro' = "iphone-15-pro",
     'iphone-16' = "iphone-16",
     'iphone-16-plus' = "iphone-16-plus",
     'iphone-16-pro' = "iphone-16-pro",
-    'iphone-16-pro-max' = "iphone-16-pro-max"
+    'iphone-16-pro-max' = "iphone-16-pro-max",
+    'iphone-17' = "iphone-17",
+    'iphone-18-pro' = "iphone-18-pro",
+    'iphone-18-pro-max' = "iphone-18-pro-max",
+    'iphone-air' = "iphone-air"
 }
 export declare enum EAndroidDevices {
     'generic-tablet' = "generic-tablet",

package/dist/types/domain/device.types.js

@@ -1,18 +1,32 @@
 /**
  * Device type definitions - should be kept in sync with API
- * @see /Users/riglar/repos/dcd/api/src/common/types/device.types.ts
+ * @see dcd/api/src/common/types/device.types.ts
+ *
+ * These drive the `--ios-device` / `--ios-version` / `--android-device` /
+ * `--android-api-level` help text and nothing else: validation runs against
+ * the live compatibility payload (device-validation.service.ts). A value the
+ * API has dropped gets a "not supported" error listing what it offers now, and
+ * one it has added is accepted even if it is missing here — so keeping these
+ * lists current only improves the help text; it never gates a run.
+ *
+ * `iphone-14-pro` and `iphone-15-pro` were listed here but have never existed
+ * in the API enum; removed 2026-09-21 rather than carried forward.
  */
 export var EiOSDevices;
 (function (EiOSDevices) {
     EiOSDevices["ipad-pro-6th-gen"] = "ipad-pro-6th-gen";
+    EiOSDevices["ipad-pro-m5-11"] = "ipad-pro-m5-11";
+    EiOSDevices["ipad-pro-m5-13"] = "ipad-pro-m5-13";
     EiOSDevices["iphone-14"] = "iphone-14";
-    EiOSDevices["iphone-14-pro"] = "iphone-14-pro";
     EiOSDevices["iphone-15"] = "iphone-15";
-    EiOSDevices["iphone-15-pro"] = "iphone-15-pro";
     EiOSDevices["iphone-16"] = "iphone-16";
     EiOSDevices["iphone-16-plus"] = "iphone-16-plus";
     EiOSDevices["iphone-16-pro"] = "iphone-16-pro";
     EiOSDevices["iphone-16-pro-max"] = "iphone-16-pro-max";
+    EiOSDevices["iphone-17"] = "iphone-17";
+    EiOSDevices["iphone-18-pro"] = "iphone-18-pro";
+    EiOSDevices["iphone-18-pro-max"] = "iphone-18-pro-max";
+    EiOSDevices["iphone-air"] = "iphone-air";
 })(EiOSDevices || (EiOSDevices = {}));
 export var EAndroidDevices;
 (function (EAndroidDevices) {