shipscreens 0.1.0

package/cli/commands/verify.js

@@ -0,0 +1,659 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import AdmZip from 'adm-zip';
+import { runValidate } from './validate.js';
+import { loadShipScreensConfig } from '../loadConfig.js';
+import { resolveOutRoot, resolveOutputPath, resolveZipOutPath } from '../outputPaths.js';
+import { formatScreenshotIndex, getScreenshotIndexWidth } from '../buildOutputs.js';
+
+function compareStrings(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+
+function normalizeProfile(profile) {
+  const normalized = String(profile || 'any')
+    .trim()
+    .toLowerCase();
+  if (!['any', 'appstore', 'playstore'].includes(normalized)) {
+    throw new Error(`Unknown verify profile: ${normalized} (expected: appstore|playstore|any)`);
+  }
+  return normalized;
+}
+
+async function statSafe(filePath) {
+  try {
+    return await fs.stat(filePath);
+  } catch (err) {
+    if (err?.code === 'ENOENT') return null;
+    throw err;
+  }
+}
+
+async function ensureDirExists(dirPath, label) {
+  const stat = await statSafe(dirPath);
+  if (!stat) {
+    throw new Error(`${label} not found: ${dirPath}\nRun: shipscreens build`);
+  }
+  if (!stat.isDirectory()) {
+    throw new Error(`${label} is not a directory: ${dirPath}`);
+  }
+}
+
+async function listDirEntries(dirPath) {
+  try {
+    return await fs.readdir(dirPath, { withFileTypes: true });
+  } catch (err) {
+    if (err?.code === 'ENOENT') return [];
+    throw err;
+  }
+}
+
+function toDeviceSlug(deviceId) {
+  return String(deviceId).toLowerCase();
+}
+
+function getAndroidBucket(device) {
+  return device.androidBucket || 'phoneScreenshots';
+}
+
+function groupAndroidDevicesByBucket(devices) {
+  const map = new Map();
+  devices.forEach((device) => {
+    const bucket = getAndroidBucket(device);
+    const existing = map.get(bucket);
+    if (existing) {
+      throw new Error(
+        `Multiple Android devices map to the same Google Play bucket (${bucket}): ${existing.id}, ${device.id}\n` +
+          `Each bucket represents a single screenshot set on Google Play (writing both would overwrite / conflict).\n` +
+          `Set only one Android device per bucket, or set devices[].androidBucket explicitly.`
+      );
+    }
+    map.set(bucket, device);
+  });
+  return map;
+}
+
+function getAllowedAndroidBuckets() {
+  return new Set(['phoneScreenshots', 'sevenInchScreenshots', 'tenInchScreenshots', 'tvScreenshots', 'wearScreenshots']);
+}
+
+function summarizePaths(label, paths, { max = 10 } = {}) {
+  if (!paths.length) return '';
+  const sorted = [...paths].sort(compareStrings);
+  const lines = [`${label}: ${sorted.length}`];
+  sorted.slice(0, max).forEach((p) => lines.push(`- ${p}`));
+  if (sorted.length > max) lines.push('(truncated)');
+  return lines.join('\n');
+}
+
+async function verifyDirOutputs({ profile, iosDir, androidDir, locales, iosDevices, androidBuckets, slideCount }) {
+  const normalizedProfile = normalizeProfile(profile);
+  const verifyIos = normalizedProfile !== 'playstore';
+  const verifyAndroid = normalizedProfile !== 'appstore';
+
+  const width = getScreenshotIndexWidth(slideCount);
+  const allowedBuckets = getAllowedAndroidBuckets();
+
+  const expectedLocales = new Set(locales);
+  const iosSlugs = new Set((iosDevices || []).map((d) => toDeviceSlug(d.id)));
+  const expectedBuckets = new Set((androidBuckets || []).map((b) => b.bucket));
+
+  const missing = [];
+  const invalid = [];
+
+  if (verifyIos && iosDevices?.length) {
+    await ensureDirExists(iosDir, 'iOS output directory');
+
+    const iosRootEntries = await listDirEntries(iosDir);
+    iosRootEntries
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name)
+      .filter((name) => !expectedLocales.has(name))
+      .sort(compareStrings)
+      .forEach((name) => invalid.push(`Unexpected iOS locale directory: ${path.join(iosDir, name)}`));
+
+    for (const localeId of locales) {
+      const localeDir = path.join(iosDir, localeId);
+      await ensureDirExists(localeDir, `iOS locale directory (${localeId})`);
+
+      const entries = await listDirEntries(localeDir);
+      const screenshotBasePattern = /^([a-z0-9_-]+)_(\d+)\.png$/i;
+      const screenshotFramedPattern = /^([a-z0-9_-]+)_(\d+)_framed\.png$/i;
+      const hasBase = entries.some((e) => e.isFile() && screenshotBasePattern.test(e.name));
+      const hasFramed = entries.some((e) => e.isFile() && screenshotFramedPattern.test(e.name));
+
+      if (normalizedProfile === 'appstore' && hasBase && hasFramed) {
+        invalid.push(
+          `Mixed iOS screenshots (unframed and _framed) are not allowed for profile=appstore: ${localeDir}\n` +
+            `Use: shipscreens stage --profile appstore --out <dir> (then upload the staged folder)`
+        );
+        continue;
+      }
+
+      const iosVariant = normalizedProfile === 'appstore' ? (hasFramed ? 'framed' : 'base') : 'base';
+
+      for (const device of iosDevices) {
+        const deviceSlug = toDeviceSlug(device.id);
+        for (let index = 1; index <= slideCount; index++) {
+          const padded = formatScreenshotIndex(index, width);
+          const suffix = iosVariant === 'framed' ? '_framed' : '';
+          const expected = path.join(localeDir, `${deviceSlug}_${padded}${suffix}.png`);
+          const stat = await statSafe(expected);
+          if (!stat || !stat.isFile()) missing.push(expected);
+        }
+      }
+
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        if (!entry.name.toLowerCase().endsWith('.png')) continue;
+
+        if (normalizedProfile === 'any') {
+          const match = screenshotBasePattern.exec(entry.name);
+          if (!match) continue;
+
+          const deviceSlug = match[1].toLowerCase();
+          const digits = match[2];
+          const num = Number.parseInt(digits, 10);
+
+          if (!iosSlugs.has(deviceSlug)) {
+            invalid.push(`Unexpected iOS screenshot file (unknown device): ${path.join(localeDir, entry.name)}`);
+            continue;
+          }
+
+          if (!Number.isFinite(num) || num < 1 || num > slideCount) {
+            invalid.push(`Unexpected iOS screenshot index (stale/out of range): ${path.join(localeDir, entry.name)}`);
+            continue;
+          }
+
+          if (digits.length !== width) {
+            invalid.push(
+              `Invalid iOS screenshot index padding (expected ${width} digits): ${path.join(localeDir, entry.name)}`
+            );
+          }
+          continue;
+        }
+
+        if (normalizedProfile === 'appstore') {
+          if (iosVariant === 'framed') {
+            const framedMatch = screenshotFramedPattern.exec(entry.name);
+            if (framedMatch) {
+              const deviceSlug = framedMatch[1].toLowerCase();
+              const digits = framedMatch[2];
+              const num = Number.parseInt(digits, 10);
+
+              if (!iosSlugs.has(deviceSlug)) {
+                invalid.push(`Unexpected iOS framed screenshot file (unknown device): ${path.join(localeDir, entry.name)}`);
+                continue;
+              }
+
+              if (!Number.isFinite(num) || num < 1 || num > slideCount) {
+                invalid.push(
+                  `Unexpected iOS framed screenshot index (stale/out of range): ${path.join(localeDir, entry.name)}`
+                );
+                continue;
+              }
+
+              if (digits.length !== width) {
+                invalid.push(
+                  `Invalid iOS framed screenshot index padding (expected ${width} digits): ${path.join(localeDir, entry.name)}`
+                );
+              }
+              continue;
+            }
+
+            const baseMatch = screenshotBasePattern.exec(entry.name);
+            if (baseMatch) {
+              invalid.push(
+                `Unframed iOS screenshot is not allowed for profile=appstore (found framed screenshots too): ${path.join(
+                  localeDir,
+                  entry.name
+                )}`
+              );
+              continue;
+            }
+
+            invalid.push(
+              `Unexpected PNG file in iOS locale directory (profile=appstore, framed): ${path.join(localeDir, entry.name)}`
+            );
+            continue;
+          }
+
+          // iosVariant === 'base'
+          const baseMatch = screenshotBasePattern.exec(entry.name);
+          if (baseMatch) {
+            const deviceSlug = baseMatch[1].toLowerCase();
+            const digits = baseMatch[2];
+            const num = Number.parseInt(digits, 10);
+
+            if (!iosSlugs.has(deviceSlug)) {
+              invalid.push(`Unexpected iOS screenshot file (unknown device): ${path.join(localeDir, entry.name)}`);
+              continue;
+            }
+
+            if (!Number.isFinite(num) || num < 1 || num > slideCount) {
+              invalid.push(`Unexpected iOS screenshot index (stale/out of range): ${path.join(localeDir, entry.name)}`);
+              continue;
+            }
+
+            if (digits.length !== width) {
+              invalid.push(
+                `Invalid iOS screenshot index padding (expected ${width} digits): ${path.join(localeDir, entry.name)}`
+              );
+            }
+            continue;
+          }
+
+          const framedMatch = screenshotFramedPattern.exec(entry.name);
+          if (framedMatch) {
+            invalid.push(
+              `Framed iOS screenshot is not allowed for profile=appstore (mixing): ${path.join(localeDir, entry.name)}`
+            );
+            continue;
+          }
+
+          invalid.push(
+            `Unexpected PNG file in iOS locale directory (profile=appstore, unframed): ${path.join(localeDir, entry.name)}`
+          );
+          continue;
+        }
+
+        // Should never reach here (verifyIos implies profile != playstore)
+        continue;
+      }
+    }
+  }
+
+  if (verifyAndroid && androidBuckets?.length) {
+    await ensureDirExists(androidDir, 'Android output directory');
+
+    const androidRootEntries = await listDirEntries(androidDir);
+    androidRootEntries
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name)
+      .filter((name) => !expectedLocales.has(name))
+      .sort(compareStrings)
+      .forEach((name) => invalid.push(`Unexpected Android locale directory: ${path.join(androidDir, name)}`));
+
+    for (const localeId of locales) {
+      const localeDir = path.join(androidDir, localeId);
+      await ensureDirExists(localeDir, `Android locale directory (${localeId})`);
+
+      const imagesDir = path.join(localeDir, 'images');
+      await ensureDirExists(imagesDir, `Android images directory (${localeId})`);
+
+      const imageEntries = await listDirEntries(imagesDir);
+      const bucketDirs = imageEntries.filter((e) => e.isDirectory()).map((e) => e.name);
+
+      bucketDirs
+        .filter((name) => !allowedBuckets.has(name))
+        .sort(compareStrings)
+        .forEach((name) => invalid.push(`Invalid Android bucket directory: ${path.join(imagesDir, name)}`));
+
+      bucketDirs
+        .filter((name) => allowedBuckets.has(name) && !expectedBuckets.has(name))
+        .sort(compareStrings)
+        .forEach((name) => invalid.push(`Unexpected Android bucket directory (not in config): ${path.join(imagesDir, name)}`));
+
+      for (const { bucket } of androidBuckets) {
+        const bucketDir = path.join(imagesDir, bucket);
+        await ensureDirExists(bucketDir, `Android bucket directory (${localeId}/${bucket})`);
+
+        for (let index = 1; index <= slideCount; index++) {
+          const padded = formatScreenshotIndex(index, width);
+          const expected = path.join(bucketDir, `${padded}.png`);
+          const stat = await statSafe(expected);
+          if (!stat || !stat.isFile()) missing.push(expected);
+        }
+
+        const entries = await listDirEntries(bucketDir);
+        const numericPng = /^(\d+)\.png$/i;
+        for (const entry of entries) {
+          if (!entry.isFile()) continue;
+          if (!entry.name.toLowerCase().endsWith('.png')) continue;
+
+          if (normalizedProfile === 'any') {
+            const match = numericPng.exec(entry.name);
+            if (!match) continue;
+
+            const digits = match[1];
+            const num = Number.parseInt(digits, 10);
+
+            if (!Number.isFinite(num) || num < 1 || num > slideCount) {
+              invalid.push(`Unexpected Android screenshot index (stale/out of range): ${path.join(bucketDir, entry.name)}`);
+              continue;
+            }
+
+            if (digits.length !== width) {
+              invalid.push(
+                `Invalid Android screenshot index padding (expected ${width} digits): ${path.join(bucketDir, entry.name)}`
+              );
+            }
+            continue;
+          }
+
+          if (normalizedProfile === 'playstore') {
+            const match = numericPng.exec(entry.name);
+            if (match) {
+              const digits = match[1];
+              const num = Number.parseInt(digits, 10);
+
+              if (!Number.isFinite(num) || num < 1 || num > slideCount) {
+                invalid.push(`Unexpected Android screenshot index (stale/out of range): ${path.join(bucketDir, entry.name)}`);
+                continue;
+              }
+
+              if (digits.length !== width) {
+                invalid.push(
+                  `Invalid Android screenshot index padding (expected ${width} digits): ${path.join(bucketDir, entry.name)}`
+                );
+              }
+              continue;
+            }
+
+            invalid.push(`Unexpected PNG file in Android bucket directory (profile=playstore): ${path.join(bucketDir, entry.name)}`);
+          }
+        }
+      }
+    }
+  }
+
+  if (missing.length || invalid.length) {
+    const parts = [];
+    if (missing.length) parts.push(summarizePaths('Missing output file(s)', missing));
+    if (invalid.length) parts.push(summarizePaths('Invalid output path(s)', invalid));
+    throw new Error(parts.filter(Boolean).join('\n'));
+  }
+
+  return { indexWidth: width };
+}
+
+async function verifyZipOutputs({ profile, zipPath, locales, iosDevices, androidBuckets, slideCount }) {
+  const normalizedProfile = normalizeProfile(profile);
+  const verifyIos = normalizedProfile !== 'playstore';
+  const verifyAndroid = normalizedProfile !== 'appstore';
+
+  const stat = await statSafe(zipPath);
+  if (!stat) {
+    throw new Error(`ZIP not found: ${zipPath}\nRun: shipscreens build --zip`);
+  }
+  if (!stat.isFile()) {
+    throw new Error(`ZIP path is not a file: ${zipPath}`);
+  }
+
+  const width = getScreenshotIndexWidth(slideCount);
+  const zip = new AdmZip(zipPath);
+  const entries = zip.getEntries().filter((e) => !e.isDirectory);
+  const names = new Set(entries.map((e) => e.entryName));
+
+  const missing = [];
+  const invalid = [];
+
+  const iosSlugs = new Set((iosDevices || []).map((d) => toDeviceSlug(d.id)));
+  const allowedBuckets = getAllowedAndroidBuckets();
+  const expectedBuckets = new Set((androidBuckets || []).map((b) => b.bucket));
+
+  const iosLocaleFlags = new Map();
+
+  const iosBasePattern = /^fastlane\/screenshots\/([^/]+)\/([a-z0-9_-]+)_(\d+)\.png$/i;
+  const iosFramedPattern = /^fastlane\/screenshots\/([^/]+)\/([a-z0-9_-]+)_(\d+)_framed\.png$/i;
+  const androidPattern = /^fastlane\/metadata\/android\/([^/]+)\/images\/([^/]+)\/(\d+)\.png$/i;
+
+  for (const entryName of names) {
+    if (verifyIos) {
+      let match = iosBasePattern.exec(entryName);
+      if (match) {
+        const localeId = match[1];
+        const flags = iosLocaleFlags.get(localeId) || { base: false, framed: false };
+        flags.base = true;
+        iosLocaleFlags.set(localeId, flags);
+      }
+      match = iosFramedPattern.exec(entryName);
+      if (match) {
+        const localeId = match[1];
+        const flags = iosLocaleFlags.get(localeId) || { base: false, framed: false };
+        flags.framed = true;
+        iosLocaleFlags.set(localeId, flags);
+      }
+    }
+  }
+
+  for (const localeId of locales) {
+    if (verifyIos) {
+      for (const device of iosDevices || []) {
+        const deviceSlug = toDeviceSlug(device.id);
+        for (let index = 1; index <= slideCount; index++) {
+          const padded = formatScreenshotIndex(index, width);
+          if (normalizedProfile === 'appstore') {
+            const flags = iosLocaleFlags.get(localeId) || { base: false, framed: false };
+            if (flags.base && flags.framed) {
+              invalid.push(
+                `Mixed iOS screenshots (unframed and _framed) are not allowed for profile=appstore: fastlane/screenshots/${localeId}/`
+              );
+              break;
+            }
+            const variant = flags.framed ? 'framed' : 'base';
+            const suffix = variant === 'framed' ? '_framed' : '';
+            const expected = path.posix.join(
+              'fastlane',
+              'screenshots',
+              localeId,
+              `${deviceSlug}_${padded}${suffix}.png`
+            );
+            if (!names.has(expected)) missing.push(expected);
+          } else {
+            const expected = path.posix.join('fastlane', 'screenshots', localeId, `${deviceSlug}_${padded}.png`);
+            if (!names.has(expected)) missing.push(expected);
+          }
+        }
+        if (normalizedProfile === 'appstore' && invalid.length) break;
+      }
+    }
+
+    if (verifyAndroid) {
+      for (const { bucket } of androidBuckets || []) {
+        for (let index = 1; index <= slideCount; index++) {
+          const padded = formatScreenshotIndex(index, width);
+          const expected = path.posix.join(
+            'fastlane',
+            'metadata',
+            'android',
+            localeId,
+            'images',
+            bucket,
+            `${padded}.png`
+          );
+          if (!names.has(expected)) missing.push(expected);
+        }
+      }
+    }
+  }
+
+  for (const entryName of names) {
+    if (entryName.toLowerCase().endsWith('.png') && entryName.toLowerCase().startsWith('fastlane/screenshots/')) {
+      if (!verifyIos) continue;
+
+      if (normalizedProfile === 'any') {
+        if (!iosBasePattern.test(entryName)) continue;
+        const match = iosBasePattern.exec(entryName);
+        const localeId = match[1];
+        const deviceSlug = match[2].toLowerCase();
+        const digits = match[3];
+        const num = Number.parseInt(digits, 10);
+
+        if (!locales.includes(localeId)) {
+          invalid.push(`Unexpected iOS locale in ZIP: ${entryName}`);
+          continue;
+        }
+        if (!iosSlugs.has(deviceSlug)) {
+          invalid.push(`Unexpected iOS device in ZIP: ${entryName}`);
+          continue;
+        }
+        if (!Number.isFinite(num) || num < 1 || num > slideCount) {
+          invalid.push(`Unexpected iOS screenshot index in ZIP: ${entryName}`);
+          continue;
+        }
+        if (digits.length !== width) {
+          invalid.push(`Invalid iOS screenshot index padding in ZIP (expected ${width} digits): ${entryName}`);
+        }
+        continue;
+      }
+
+      if (normalizedProfile === 'appstore') {
+        const baseMatch = iosBasePattern.exec(entryName);
+        const framedMatch = iosFramedPattern.exec(entryName);
+        const match = framedMatch || baseMatch;
+        if (!match) {
+          invalid.push(`Unexpected iOS PNG in ZIP (profile=appstore): ${entryName}`);
+          continue;
+        }
+
+        const localeId = match[1];
+        const deviceSlug = match[2].toLowerCase();
+        const digits = match[3];
+        const num = Number.parseInt(digits, 10);
+
+        if (!locales.includes(localeId)) {
+          invalid.push(`Unexpected iOS locale in ZIP: ${entryName}`);
+          continue;
+        }
+        if (!iosSlugs.has(deviceSlug)) {
+          invalid.push(`Unexpected iOS device in ZIP: ${entryName}`);
+          continue;
+        }
+        if (!Number.isFinite(num) || num < 1 || num > slideCount) {
+          invalid.push(`Unexpected iOS screenshot index in ZIP: ${entryName}`);
+          continue;
+        }
+        if (digits.length !== width) {
+          invalid.push(`Invalid iOS screenshot index padding in ZIP (expected ${width} digits): ${entryName}`);
+        }
+
+        const flags = iosLocaleFlags.get(localeId) || { base: false, framed: false };
+        if (flags.base && flags.framed) continue; // mixing already reported above
+        const variant = flags.framed ? 'framed' : 'base';
+        const isFramedEntry = Boolean(framedMatch);
+        if (variant === 'framed' && !isFramedEntry) {
+          invalid.push(`Unframed iOS screenshot is not allowed for profile=appstore (mixing): ${entryName}`);
+        }
+        if (variant === 'base' && isFramedEntry) {
+          invalid.push(`Framed iOS screenshot is not allowed for profile=appstore (mixing): ${entryName}`);
+        }
+        continue;
+      }
+    }
+
+    if (androidPattern.test(entryName)) {
+      if (!verifyAndroid) continue;
+
+      const match = androidPattern.exec(entryName);
+      const localeId = match[1];
+      const bucket = match[2];
+      const digits = match[3];
+      const num = Number.parseInt(digits, 10);
+
+      if (!locales.includes(localeId)) {
+        invalid.push(`Unexpected Android locale in ZIP: ${entryName}`);
+        continue;
+      }
+      if (!allowedBuckets.has(bucket)) {
+        invalid.push(`Invalid Android bucket in ZIP: ${entryName}`);
+        continue;
+      }
+      if (!expectedBuckets.has(bucket)) {
+        invalid.push(`Unexpected Android bucket in ZIP (not in config): ${entryName}`);
+        continue;
+      }
+      if (!Number.isFinite(num) || num < 1 || num > slideCount) {
+        invalid.push(`Unexpected Android screenshot index in ZIP: ${entryName}`);
+        continue;
+      }
+      if (digits.length !== width) {
+        invalid.push(`Invalid Android screenshot index padding in ZIP (expected ${width} digits): ${entryName}`);
+      }
+      continue;
+    }
+
+    if (normalizedProfile === 'playstore') {
+      if (!verifyAndroid) continue;
+      if (entryName.toLowerCase().endsWith('.png') && entryName.toLowerCase().startsWith('fastlane/metadata/android/')) {
+        invalid.push(`Unexpected Android PNG in ZIP (profile=playstore): ${entryName}`);
+      }
+    }
+  }
+
+  if (missing.length || invalid.length) {
+    const parts = [];
+    if (missing.length) parts.push(summarizePaths('Missing ZIP entry/entries', missing));
+    if (invalid.length) parts.push(summarizePaths('Invalid ZIP entry/entries', invalid));
+    throw new Error(parts.filter(Boolean).join('\n'));
+  }
+}
+
+export async function runVerify({ configPath, outDir, iosDir, androidDir, zipOut, zip = false, profile } = {}) {
+  const normalizedProfile = normalizeProfile(profile);
+  await runValidate({ configPath });
+  const { config, configDir } = await loadShipScreensConfig(configPath);
+  const outRoot = resolveOutRoot({ configDir, outDir });
+
+  const resolvedIosDir = resolveOutputPath({
+    outRoot,
+    value: iosDir || config.output?.directory,
+    fallback: 'fastlane/screenshots',
+  });
+  const resolvedAndroidDir = resolveOutputPath({
+    outRoot,
+    value: androidDir || config.output?.androidDirectory,
+    fallback: 'fastlane/metadata/android',
+  });
+
+  const devices = Array.isArray(config.devices) ? config.devices : [];
+  const iosDevices = devices.filter((d) => d.platform !== 'android');
+  const androidDevices = devices.filter((d) => d.platform === 'android');
+  const androidBuckets = [...groupAndroidDevicesByBucket(androidDevices).entries()]
+    .sort(([a], [b]) => compareStrings(a, b))
+    .map(([bucket, device]) => ({ bucket, device }));
+
+  const locales = (config.locales || []).map((l) => l.id).sort(compareStrings);
+  const slideCount = config.slides.length;
+
+  if (normalizedProfile === 'appstore' && !iosDevices.length) {
+    throw new Error(`No iOS devices configured. Add at least one iOS device, or use --profile playstore.`);
+  }
+  if (normalizedProfile === 'playstore' && !androidBuckets.length) {
+    throw new Error(`No Android devices configured. Add at least one Android device, or use --profile appstore.`);
+  }
+
+  await verifyDirOutputs({
+    profile: normalizedProfile,
+    iosDir: resolvedIosDir,
+    androidDir: resolvedAndroidDir,
+    locales,
+    iosDevices,
+    androidBuckets,
+    slideCount,
+  });
+
+  let resolvedZipPath = null;
+  if (zip) {
+    resolvedZipPath = resolveZipOutPath({ outRoot, zipOut });
+    await verifyZipOutputs({
+      profile: normalizedProfile,
+      zipPath: resolvedZipPath,
+      locales,
+      iosDevices,
+      androidBuckets,
+      slideCount,
+    });
+  }
+
+  return {
+    iosDir: resolvedIosDir,
+    androidDir: resolvedAndroidDir,
+    zipPath: resolvedZipPath,
+    locales: locales.length,
+    slides: slideCount,
+    iosDevices: iosDevices.length,
+    androidDevices: androidDevices.length,
+  };
+}