@tomako/tools-runtime 0.1.0

package/src/features/tools/app-store-screenshot-generator/widget/generation.ts

@@ -0,0 +1,528 @@
+import type { AppLocale } from "../../../../i18n/locale";
+import {
+    APP_STORE_SCREENSHOT_GENERATOR_PROMPT_META,
+    type AppStoreScreenshotAgentResult,
+    type AppStoreScreenshotAsset,
+    type AppStoreScreenshotGeneratorInput,
+} from "../../../../lib/tools/app-store-screenshot-generator-schema";
+import { imageDownloadUrl } from "../../../../lib/tools/image-download";
+import { fetchImageGenerationResult } from "../../../../host/client";
+import {
+    fetchAppStoreScreenshotSetTask,
+    submitAppStoreScreenshotSet,
+    type AppStoreScreenshotSetErrorCode,
+} from "../../../../host/client";
+
+import { clampAssetCount } from "./asset-slots";
+import {
+    AGENT_RESULT_POLL_INTERVAL_MS,
+    AGENT_RESULT_TIMEOUT_MS,
+    IMAGE_POLL_INTERVAL_MS,
+    IMAGE_POLL_TIMEOUT_MS,
+} from "./constants";
+import type {
+    AssetFormat,
+    AssetGenerationFailure,
+    AssetSpec,
+    GeneratedStoreAssetsResult,
+} from "./types";
+import { escapeXml } from "./zip";
+
+export async function generateStoreAssets(
+  input: AppStoreScreenshotGeneratorInput,
+  locale: AppLocale,
+  onProgress: (progress: GeneratedStoreAssetsResult) => void,
+  onPlanning: () => void,
+): Promise<GeneratedStoreAssetsResult> {
+  const submitted = await submitAppStoreScreenshotSet(input, locale);
+  onPlanning();
+  const agentResult = await waitForAgentResult(submitted.taskId, (partialResult) => {
+    try {
+      onProgress(buildGeneratedStoreAssetsResult(partialResult, { allowMissingImageUrl: false }));
+    } catch {
+      // Ignore non-renderable intermediate snapshots and keep waiting for a usable result.
+    }
+  });
+  return resolveGeneratedStoreAssetsResult(agentResult, input, onProgress);
+}
+
+export async function resolveGeneratedStoreAssetsResult(
+  agentResult: AppStoreScreenshotAgentResult,
+  input: AppStoreScreenshotGeneratorInput,
+  onProgress: (progress: GeneratedStoreAssetsResult) => void,
+): Promise<GeneratedStoreAssetsResult> {
+  const resolvedAssets: Array<AppStoreScreenshotAgentResult["assets"][number] | undefined> =
+    new Array(agentResult.assets.length);
+  const failures = [...agentResult.failures];
+  const totalAssets = agentResult.totalAssets ?? agentResult.assets.length;
+
+  await Promise.all(
+    agentResult.assets.map(async (agentAsset, index) => {
+      if (agentAsset.imageUrl) {
+        resolvedAssets[index] = agentAsset;
+        emitResolvedAssetProgress(agentResult, resolvedAssets, failures, totalAssets, onProgress);
+        return;
+      }
+
+      if (!agentAsset.imageTaskId) {
+        failures.push({
+          id: agentAsset.id,
+          title: agentAsset.title,
+          message: agentAsset.errorMessage || "Agent result did not include an image task.",
+        });
+        emitResolvedAssetProgress(agentResult, resolvedAssets, failures, totalAssets, onProgress);
+        return;
+      }
+
+      try {
+        const image = await waitForImageGeneration(agentAsset.imageTaskId);
+        const resolvedAsset = {
+          ...agentAsset,
+          imageUrl: image.imageUrl,
+          status: image.status,
+        };
+        resolvedAssets[index] = resolvedAsset;
+      } catch (error) {
+        failures.push({
+          id: agentAsset.id,
+          title: agentAsset.title,
+          message: errorToMessage(error),
+        });
+      }
+      emitResolvedAssetProgress(agentResult, resolvedAssets, failures, totalAssets, onProgress);
+    }),
+  );
+
+  return buildGeneratedStoreAssetsResult(
+    withResolvedAgentAssets(agentResult, resolvedAssets, failures, {
+      reportStatus: "final",
+      totalAssets,
+      estimatedRemainingSeconds: 0,
+    }),
+    { allowMissingImageUrl: false },
+  );
+}
+
+export function emitResolvedAssetProgress(
+  agentResult: AppStoreScreenshotAgentResult,
+  resolvedAssets: Array<AppStoreScreenshotAgentResult["assets"][number] | undefined>,
+  failures: AppStoreScreenshotAgentResult["failures"],
+  totalAssets: number,
+  onProgress: (progress: GeneratedStoreAssetsResult) => void,
+) {
+  const completedAssets = resolvedAssets.filter(Boolean).length;
+  if (!completedAssets) return;
+
+  const partialResult = withResolvedAgentAssets(agentResult, resolvedAssets, failures, {
+    reportStatus: completedAssets + failures.length >= totalAssets ? "final" : "partial",
+    totalAssets,
+    estimatedRemainingSeconds: Math.max(0, (totalAssets - completedAssets - failures.length) * 45),
+  });
+
+  try {
+    onProgress(buildGeneratedStoreAssetsResult(partialResult, { allowMissingImageUrl: false }));
+  } catch {
+    // Keep polling other image tasks even if an intermediate snapshot is not renderable yet.
+  }
+}
+
+export function withResolvedAgentAssets(
+  agentResult: AppStoreScreenshotAgentResult,
+  resolvedAssets: Array<AppStoreScreenshotAgentResult["assets"][number] | undefined>,
+  failures: AppStoreScreenshotAgentResult["failures"],
+  overrides: {
+    reportStatus: AppStoreScreenshotAgentResult["reportStatus"];
+    totalAssets: number;
+    estimatedRemainingSeconds: number;
+  },
+): AppStoreScreenshotAgentResult {
+  const assets = resolvedAssets.filter(
+    (asset): asset is AppStoreScreenshotAgentResult["assets"][number] => Boolean(asset),
+  );
+
+  return {
+    ...agentResult,
+    assets,
+    failures,
+    reportStatus: overrides.reportStatus,
+    totalAssets: overrides.totalAssets,
+    completedAssets: assets.length,
+    failedAssets: failures.length,
+    estimatedRemainingSeconds: overrides.estimatedRemainingSeconds,
+    inProgressAsset: agentResult.assets.find(
+      (asset) =>
+        !assets.some((resolvedAsset) => resolvedAsset.id === asset.id) &&
+        !failures.some((failure) => failure.id === asset.id),
+    ),
+  };
+}
+
+export function buildGeneratedStoreAssetsResult(
+  agentResult: AppStoreScreenshotAgentResult,
+  options: { allowMissingImageUrl: boolean },
+): GeneratedStoreAssetsResult {
+  const assets: AppStoreScreenshotAsset[] = [];
+  const failures: AssetGenerationFailure[] = [];
+
+  for (const agentAsset of agentResult.assets) {
+    const spec = agentAssetToSpec(agentAsset);
+    if (!agentAsset.imageUrl) {
+      if (!options.allowMissingImageUrl) continue;
+      failures.push({
+        spec,
+        message: agentAsset.errorMessage || "Agent result did not include an image task.",
+      });
+      continue;
+    }
+
+    assets.push({
+      id: agentAsset.id,
+      platform: agentAsset.platform,
+      format: agentAsset.format,
+      title: agentAsset.title,
+      width: agentAsset.width,
+      height: agentAsset.height,
+      slot: agentAsset.slot,
+      setSize: agentAsset.setSize,
+      imageTaskId: agentAsset.imageTaskId,
+      imageUrl: agentAsset.imageUrl,
+      svg: buildGeneratedImageSvg(
+        {
+          id: agentAsset.id,
+          platform: agentAsset.platform,
+          format: agentAsset.format,
+          title: agentAsset.title,
+          width: agentAsset.width,
+          height: agentAsset.height,
+          slot: agentAsset.slot,
+          setSize: agentAsset.setSize,
+          imageTaskId: agentAsset.imageTaskId,
+          imageUrl: agentAsset.imageUrl,
+        },
+        agentAsset.prompt || agentResult.prompt,
+      ),
+    });
+  }
+
+  for (const failure of agentResult.failures) {
+    failures.push({
+      spec: {
+        id: failure.id,
+        format: "iphone",
+        title: failure.title || failure.id,
+        width: 1290,
+        height: 2796,
+        variant: 0,
+        slot: 1,
+        setSize: agentResult.totalAssets ?? agentResult.assets.length,
+        storyAngle: "",
+        copyIntent: "",
+        composition: "",
+      },
+      message: failure.message,
+    });
+  }
+
+  if (assets.length === 0) {
+    throw new AppStoreAssetGenerationError(failures);
+  }
+
+  return {
+    output: {
+      promptId: APP_STORE_SCREENSHOT_GENERATOR_PROMPT_META.id,
+      promptVersion: APP_STORE_SCREENSHOT_GENERATOR_PROMPT_META.version,
+      prompt: agentResult.prompt,
+      assets,
+    },
+    failures,
+    reportStatus: agentResult.reportStatus,
+    completedCount: agentResult.completedAssets ?? assets.length,
+    totalCount: agentResult.totalAssets ?? Math.max(agentResult.assets.length, assets.length),
+    failedCount: agentResult.failedAssets ?? failures.length,
+    inProgressTitle: agentResult.inProgressAsset?.title,
+    estimatedRemainingSeconds: agentResult.estimatedRemainingSeconds,
+  };
+}
+
+export async function waitForAgentResult(
+  taskId: string,
+  onProgress: (result: AppStoreScreenshotAgentResult) => void,
+) {
+  const deadline = Date.now() + AGENT_RESULT_TIMEOUT_MS;
+  let lastResult: AppStoreScreenshotAgentResult | null = null;
+  let lastSignature = "";
+
+  while (Date.now() < deadline) {
+    const task = await fetchAppStoreScreenshotSetTask(taskId);
+    if (task.data) {
+      lastResult = task.data;
+      const signature = progressSignature(task.data);
+      if (signature !== lastSignature) {
+        lastSignature = signature;
+        onProgress(task.data);
+      }
+      if (task.data.reportStatus === "final" || hasResolvableAgentAssets(task.data)) {
+        return task.data;
+      }
+    }
+    if (task.errorCode || task.status === "FAILED") {
+      if (lastResult) return lastResult;
+      throw new AppStoreAgentGenerationError(task.errorCode, task.error);
+    }
+    await wait(AGENT_RESULT_POLL_INTERVAL_MS);
+  }
+
+  if (lastResult) return lastResult;
+  throw new AppStoreAgentGenerationError("task_failed", "Agent result timed out.");
+}
+
+export function hasResolvableAgentAssets(result: AppStoreScreenshotAgentResult) {
+  return result.assets.some((asset) => Boolean(asset.imageUrl || asset.imageTaskId));
+}
+
+export function progressSignature(result: AppStoreScreenshotAgentResult) {
+  return [
+    result.reportStatus,
+    result.completedAssets,
+    result.failedAssets,
+    result.estimatedRemainingSeconds,
+    result.assets
+      .map((asset) => `${asset.id}:${asset.imageTaskId ?? ""}:${asset.imageUrl ?? ""}`)
+      .join("|"),
+    result.failures.map((failure) => `${failure.id}:${failure.message}`).join("|"),
+  ].join("::");
+}
+
+export function expectedAssetCount(input: AppStoreScreenshotGeneratorInput) {
+  return clampAssetCount(input.assetCount);
+}
+
+export function initialEstimatedSeconds(input: AppStoreScreenshotGeneratorInput) {
+  return expectedAssetCount(input) * 90 + 120;
+}
+
+
+export function formatRemainingTime(
+  seconds: number,
+  labels: {
+    minutes: (minutes: number) => string;
+    stillWorking: string;
+  },
+) {
+  if (seconds <= 0) return labels.stillWorking;
+  return labels.minutes(Math.max(1, Math.ceil(seconds / 60)));
+}
+
+export function agentAssetToSpec(asset: {
+  id: string;
+  format: AssetFormat;
+  title: string;
+  width: number;
+  height: number;
+  slot?: number;
+  setSize?: number;
+}): AssetSpec {
+  return {
+    id: asset.id,
+    format: asset.format,
+    title: asset.title,
+    width: asset.width,
+    height: asset.height,
+    variant: Math.max((asset.slot ?? 1) - 1, 0),
+    slot: asset.slot ?? 1,
+    setSize: asset.setSize ?? 1,
+    storyAngle: "",
+    copyIntent: "",
+    composition: "",
+  };
+}
+
+export async function waitForImageGeneration(imageTaskId: string) {
+  const deadline = Date.now() + IMAGE_POLL_TIMEOUT_MS;
+
+  while (Date.now() < deadline) {
+    const result = await fetchImageGenerationResult(imageTaskId);
+    if (result.status === "SUCCEEDED" && result.imageUrl) return result;
+    if (result.status === "FAILED") {
+      throw new ImageGenerationFailedError(
+        imageTaskId,
+        result.errorMessage || `Image task failed: ${imageTaskId}`,
+      );
+    }
+    await wait(IMAGE_POLL_INTERVAL_MS);
+  }
+
+  throw new ImageGenerationFailedError(imageTaskId, `Image generation timed out: ${imageTaskId}`);
+}
+
+export async function loadImageForCanvas(url: string): Promise<HTMLImageElement> {
+  if (url.startsWith("data:image/") || url.startsWith("blob:")) {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`Image load failed: ${response.status}`);
+    return blobToImage(await response.blob());
+  }
+
+  const response = await fetch(imageDownloadUrl(url), { cache: "no-store" });
+  if (!response.ok) throw new Error(`Image download failed: ${response.status}`);
+  return blobToImage(await response.blob());
+}
+
+export function buildGeneratedImageSvg(asset: AppStoreScreenshotAsset, prompt: string) {
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${asset.width}" height="${asset.height}" viewBox="0 0 ${asset.width} ${asset.height}" role="img" aria-label="${escapeXml(asset.format)} generated app store image">
+  <metadata>${escapeXml(prompt)}</metadata>
+  <image href="${escapeXml(asset.imageUrl ?? "")}" width="${asset.width}" height="${asset.height}" preserveAspectRatio="xMidYMid meet"/>
+</svg>`;
+}
+
+export async function renderAssetToPngBlob(asset: AppStoreScreenshotAsset): Promise<Blob> {
+  if (asset.imageUrl) return renderRemoteImageToPngBlob(asset);
+  if (asset.svg) return renderSvgAssetToPngBlob(asset);
+  throw new Error("Missing generated image source.");
+}
+
+export async function renderRemoteImageToPngBlob(asset: AppStoreScreenshotAsset): Promise<Blob> {
+  if (!asset.imageUrl) throw new Error("Missing image URL.");
+
+  const image = await loadImageForCanvas(asset.imageUrl);
+  const canvas = document.createElement("canvas");
+  canvas.width = asset.width;
+  canvas.height = asset.height;
+  const context = canvas.getContext("2d");
+  if (!context) throw new Error("Canvas context unavailable.");
+
+  context.fillStyle = "#FFFFFF";
+  context.fillRect(0, 0, canvas.width, canvas.height);
+
+  const scale = Math.min(canvas.width / image.naturalWidth, canvas.height / image.naturalHeight);
+  const drawWidth = image.naturalWidth * scale;
+  const drawHeight = image.naturalHeight * scale;
+  const drawX = (canvas.width - drawWidth) / 2;
+  const drawY = (canvas.height - drawHeight) / 2;
+  context.drawImage(image, drawX, drawY, drawWidth, drawHeight);
+
+  return new Promise((resolve, reject) => {
+    canvas.toBlob((blob) => {
+      if (blob) resolve(blob);
+      else reject(new Error("PNG export failed."));
+    }, "image/png");
+  });
+}
+
+export async function renderSvgAssetToPngBlob(asset: AppStoreScreenshotAsset): Promise<Blob> {
+  if (!asset.svg) throw new Error("Missing SVG source.");
+
+  const svgBlob = new Blob([asset.svg], {
+    type: "image/svg+xml;charset=utf-8",
+  });
+  const svgUrl = URL.createObjectURL(svgBlob);
+  const image = new Image();
+
+  try {
+    await new Promise<void>((resolve, reject) => {
+      image.onload = () => resolve();
+      image.onerror = () => reject(new Error("SVG decode failed."));
+      image.src = svgUrl;
+    });
+
+    const canvas = document.createElement("canvas");
+    canvas.width = asset.width;
+    canvas.height = asset.height;
+    const context = canvas.getContext("2d");
+    if (!context) throw new Error("Canvas context unavailable.");
+
+    context.drawImage(image, 0, 0, canvas.width, canvas.height);
+    return await new Promise((resolve, reject) => {
+      canvas.toBlob((blob) => {
+        if (blob) resolve(blob);
+        else reject(new Error("PNG export failed."));
+      }, "image/png");
+    });
+  } finally {
+    URL.revokeObjectURL(svgUrl);
+  }
+}
+
+export function blobToImage(blob: Blob): Promise<HTMLImageElement> {
+  return new Promise((resolve, reject) => {
+    const url = URL.createObjectURL(blob);
+    const image = new Image();
+    image.onload = () => {
+      URL.revokeObjectURL(url);
+      resolve(image);
+    };
+    image.onerror = () => {
+      URL.revokeObjectURL(url);
+      reject(new Error("Image decode failed."));
+    };
+    image.src = url;
+  });
+}
+
+export function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => window.setTimeout(resolve, ms));
+}
+
+export function formatGenerationError(
+  error: unknown,
+  labels: {
+    generic: string;
+    withDetail: (detail: string) => string;
+    formatLabel: (format: AssetFormat) => string;
+  },
+) {
+  if (error instanceof AppStoreAgentGenerationError) {
+    return labels.withDetail(truncateErrorDetail(error.message));
+  }
+
+  if (error instanceof AppStoreAssetGenerationError) {
+    const detail = error.failures
+      .slice(0, 3)
+      .map((failure) => {
+        const format = failure.spec.title || labels.formatLabel(failure.spec.format);
+        return `${format}: ${truncateErrorDetail(failure.message)}`;
+      })
+      .join("; ");
+    return detail ? labels.withDetail(detail) : labels.generic;
+  }
+
+  const message = errorToMessage(error);
+  return message ? labels.withDetail(truncateErrorDetail(message)) : labels.generic;
+}
+
+export function errorToMessage(error: unknown) {
+  if (error instanceof Error && error.message) return error.message;
+  if (typeof error === "string") return error;
+  return "Unknown image task error";
+}
+
+export function truncateErrorDetail(value: string) {
+  const trimmed = value.replace(/\s+/g, " ").trim();
+  return trimmed.length > 180 ? `${trimmed.slice(0, 177)}...` : trimmed;
+}
+
+export class AppStoreAssetGenerationError extends Error {
+  constructor(public readonly failures: AssetGenerationFailure[]) {
+    super("All app store image tasks failed.");
+    this.name = "AppStoreAssetGenerationError";
+  }
+}
+
+export class AppStoreAgentGenerationError extends Error {
+  constructor(
+    public readonly code: AppStoreScreenshotSetErrorCode | undefined,
+    message?: string,
+  ) {
+    super(message || code || "Agent did not return a valid app store screenshot result.");
+    this.name = "AppStoreAgentGenerationError";
+  }
+}
+
+export class ImageGenerationFailedError extends Error {
+  constructor(
+    public readonly imageTaskId: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = "ImageGenerationFailedError";
+  }
+}

package/src/features/tools/app-store-screenshot-generator/widget/index.ts

@@ -0,0 +1,7 @@
+"use client";
+
+import dynamic from "next/dynamic";
+
+export const AppStoreScreenshotGenerator = dynamic(() =>
+  import("./app-store-screenshot-generator").then((module) => module.AppStoreScreenshotGenerator),
+);

package/src/features/tools/app-store-screenshot-generator/widget/input-media.ts

@@ -0,0 +1,175 @@
+import type {
+    AppStoreScreenshotAsset,
+    AppStoreScreenshotGeneratorInput,
+} from "../../../../lib/tools/app-store-screenshot-generator-schema";
+
+import { renderAssetToPngBlob } from "./generation";
+import type { SourceKey } from "./types";
+import { createZipBlob, slugForFileName, type ZipFileInput } from "./zip";
+
+export function inferSource(input: AppStoreScreenshotGeneratorInput): SourceKey {
+  const hasUrl = input.productUrl.trim().length > 0;
+  const hasScreenshot = Boolean(
+    input.screenshotReferences?.length || input.screenshotDataUrl || input.hasScreenshot,
+  );
+  if (hasUrl && hasScreenshot) return "mixed";
+  if (hasUrl) return "url";
+  if (hasScreenshot) return "upload";
+  return "brief";
+}
+
+export async function readImageAsset(
+  file: File,
+  options: { maxEdge: number; quality: number; maxDataUrlLength: number },
+): Promise<{ dataUrl: string; width: number; height: number }> {
+  const rawDataUrl = await readFileAsDataUrl(file);
+  const image = await dataUrlToImage(rawDataUrl);
+  let maxEdge = options.maxEdge;
+  let quality = options.quality;
+  let rendered = renderImageDataUrl(image, maxEdge, quality);
+
+  for (let attempt = 0; attempt < 6 && rendered.dataUrl.length > options.maxDataUrlLength; attempt += 1) {
+    maxEdge = Math.max(220, Math.round(maxEdge * 0.78));
+    quality = Math.max(0.42, quality - 0.06);
+    rendered = renderImageDataUrl(image, maxEdge, quality);
+  }
+
+  return rendered;
+}
+
+export function getScreenshotReferenceReadOptions(count: number) {
+  if (count <= 3) {
+    return {
+      maxEdge: 920,
+      quality: 0.72,
+      maxDataUrlLength: 180_000,
+    };
+  }
+
+  return {
+    maxEdge: 720,
+    quality: 0.64,
+    maxDataUrlLength: 110_000,
+  };
+}
+
+export function renderImageDataUrl(
+  image: HTMLImageElement,
+  maxEdge: number,
+  quality: number,
+): { dataUrl: string; width: number; height: number } {
+  const scale = Math.min(1, maxEdge / Math.max(image.naturalWidth, image.naturalHeight));
+  const width = Math.max(1, Math.round(image.naturalWidth * scale));
+  const height = Math.max(1, Math.round(image.naturalHeight * scale));
+
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  const context = canvas.getContext("2d");
+  if (!context) throw new Error("Canvas context unavailable.");
+  context.fillStyle = "#FFFFFF";
+  context.fillRect(0, 0, width, height);
+  context.drawImage(image, 0, 0, width, height);
+
+  return {
+    dataUrl: canvas.toDataURL("image/jpeg", quality),
+    width,
+    height,
+  };
+}
+
+export function readFileAsDataUrl(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = typeof reader.result === "string" ? reader.result : "";
+      if (result) resolve(result);
+      else reject(new Error("File read failed."));
+    };
+    reader.onerror = () => reject(new Error("File read failed."));
+    reader.readAsDataURL(file);
+  });
+}
+
+export function dataUrlToImage(dataUrl: string): Promise<HTMLImageElement> {
+  return new Promise((resolve, reject) => {
+    const image = new Image();
+    image.onload = () => resolve(image);
+    image.onerror = () => reject(new Error("Image decode failed."));
+    image.src = dataUrl;
+  });
+}
+
+export function normalizeUrl(value: string) {
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  return `https://${trimmed}`;
+}
+
+export function deriveProductName(url: string) {
+  try {
+    const hostname = new URL(normalizeUrl(url)).hostname.replace(/^www\./, "");
+    const first = hostname.split(".")[0];
+    return first ? first.charAt(0).toUpperCase() + first.slice(1) : "";
+  } catch {
+    return "";
+  }
+}
+
+export function assetFileBase(input: AppStoreScreenshotGeneratorInput, asset: AppStoreScreenshotAsset) {
+  const name =
+    input.productName || deriveProductName(input.productUrl) || "store-screenshot";
+  return `${slugForFileName(name) || "store-screenshot"}-${asset.platform}-${asset.format}`;
+}
+
+export function buildScreenshotsZipName(
+  input: AppStoreScreenshotGeneratorInput,
+  scope: "selected" | "all",
+) {
+  const name =
+    input.productName || deriveProductName(input.productUrl) || "store-screenshot";
+  const base = slugForFileName(name) || "store-screenshot";
+  return `${base}-${scope === "all" ? "all" : "selected"}-screenshots.zip`;
+}
+
+export async function createGeneratedAssetsZip(
+  assets: readonly AppStoreScreenshotAsset[],
+  input: AppStoreScreenshotGeneratorInput,
+): Promise<Blob> {
+  const files: ZipFileInput[] = [];
+  const usedPaths = new Set<string>();
+
+  for (const [index, asset] of assets.entries()) {
+    const blob = await renderAssetToPngBlob(asset);
+    const path = uniqueZipPath(
+      usedPaths,
+      `${String(index + 1).padStart(2, "0")}-${assetFileBase(input, asset)}-${slugForFileName(asset.title ?? asset.id)}.png`,
+    );
+    files.push({
+      path,
+      data: new Uint8Array(await blob.arrayBuffer()),
+    });
+  }
+
+  return createZipBlob(files);
+}
+
+export function uniqueZipPath(usedPaths: Set<string>, path: string) {
+  if (!usedPaths.has(path)) {
+    usedPaths.add(path);
+    return path;
+  }
+
+  const extensionIndex = path.lastIndexOf(".");
+  const stem = extensionIndex >= 0 ? path.slice(0, extensionIndex) : path;
+  const extension = extensionIndex >= 0 ? path.slice(extensionIndex) : "";
+  let index = 2;
+  let next = `${stem}-${index}${extension}`;
+  while (usedPaths.has(next)) {
+    index += 1;
+    next = `${stem}-${index}${extension}`;
+  }
+  usedPaths.add(next);
+  return next;
+}