@webflow/cloud-app 0.1.0-beta.10

package/dist/frameworks/astro/templates/v5/astro.config.mjs.template

@@ -0,0 +1,25 @@
+// Generated by the Webflow Cloud builder. Merge logic lives in ./astro.config.webflow.ts.
+import { defineConfig } from 'astro/config';
+import cloudflare from '@astrojs/cloudflare';
+import react from '@astrojs/react';
+import userConfig from './clouduser.astro.config';
+import { withWebflowOverrides } from './astro.config.webflow';
+
+export default defineConfig(
+  withWebflowOverrides(userConfig, {
+    mountPath: '${COSMIC_MOUNT_PATH}',
+    deployUrl: '${COSMIC_DEPLOY_URL}',
+    adapter: cloudflare({
+      imageService: 'custom',
+      platformProxy: {
+        enabled: true,
+      },
+    }),
+    reactIntegration: react(),
+    // Use react-dom/server.edge instead of react-dom/server.browser for React 19.
+    // Without this, MessageChannel from node:worker_threads needs to be polyfilled.
+    reactDomServerAlias: import.meta.env.PROD
+      ? { 'react-dom/server': 'react-dom/server.edge' }
+      : undefined,
+  }),
+);

package/dist/frameworks/astro/templates/v5/webflow-loader.ts

@@ -0,0 +1,126 @@
+/**
+ * Webflow Image Loader for Astro 5
+ *
+ * A custom Astro image service that resizes images on demand through
+ * Cloudflare's zone-level Image Resizing (`/cdn-cgi/image/...`). URL-building
+ * and responsive-width logic live in the framework-agnostic ./webflow-image-url
+ * helper (unit-tested); this file is the thin Astro-typed glue. Same loader as
+ * Astro 6 and 7.
+ *
+ * We set the adapter's imageService to 'custom' to keep resizing on the zone
+ * endpoint rather than the Worker Images binding.
+ */
+
+import type { ExternalImageService, ImageTransform, AstroConfig } from 'astro';
+import { normalizeSrc, isRemote, buildImageUrl, computeSrcSetWidths } from './webflow-image-url';
+
+// Default implementation copied from Astro's baseService
+function getTargetDimensions(options: ImageTransform) {
+  let targetWidth = options.width;
+  let targetHeight = options.height;
+
+  // For ESM imported images, calculate missing dimensions based on aspect ratio
+  if (typeof options.src === 'object' && 'width' in options.src && 'height' in options.src) {
+    const aspectRatio = options.src.width / options.src.height;
+    if (targetHeight && !targetWidth) {
+      targetWidth = Math.round(targetHeight * aspectRatio);
+    } else if (targetWidth && !targetHeight) {
+      targetHeight = Math.round(targetWidth / aspectRatio);
+    } else if (!targetWidth && !targetHeight) {
+      targetWidth = options.src.width;
+      targetHeight = options.src.height;
+    }
+  }
+
+  return {
+    targetWidth,
+    targetHeight,
+  };
+}
+
+const cloudflareLoader: ExternalImageService = {
+  getURL(options: ImageTransform, imageConfig: AstroConfig['image']) {
+    const { deployUrl, mountPath } = imageConfig.service.config;
+    const normalizedSrc = normalizeSrc(
+      typeof options.src === 'object' ? options.src.src : options.src,
+      deployUrl,
+      mountPath,
+    );
+    const isSvg =
+      typeof options.src === 'object' ? options.src.format === 'svg' : options.src.endsWith('.svg');
+
+    return buildImageUrl(
+      normalizedSrc,
+      {
+        width: options.width,
+        height: options.height,
+        quality: options.quality,
+        format: options.format,
+      },
+      deployUrl,
+      isSvg,
+    );
+  },
+
+  // Responsive variants. Astro resolves each entry's URL by calling getURL on
+  // its `transform`, so format=auto (set in getURL) flows through here too.
+  getSrcSet(options: ImageTransform, imageConfig: AstroConfig['image']) {
+    // Mirror getURL's passthrough: remote and SVG sources are not resized, so a
+    // srcset of identical URLs would be misleading markup. Normalize first, as
+    // getURL does, since build.assetsPrefix makes local asset srcs absolute on
+    // the deploy origin.
+    const { deployUrl, mountPath } = imageConfig.service.config;
+    const srcString = typeof options.src === 'object' ? options.src.src : options.src;
+    const normalizedSrc = normalizeSrc(srcString, deployUrl, mountPath);
+    const isSvg =
+      typeof options.src === 'object' ? options.src.format === 'svg' : srcString.endsWith('.svg');
+    if (isSvg || isRemote(normalizedSrc)) {
+      return [];
+    }
+
+    const { targetWidth, targetHeight } = getTargetDimensions(options);
+    const maxWidth =
+      typeof options.src === 'object' && 'width' in options.src ? options.src.width : undefined;
+
+    return computeSrcSetWidths(options, targetWidth, targetHeight, maxWidth).map(
+      ({ width, height, descriptor }) => ({
+        transform: { ...options, width, height },
+        descriptor,
+        // Only advertise a MIME type when a concrete format was requested. With
+        // the default (format=auto) Cloudflare negotiates the output, so
+        // `type: "image/auto"` would be an invalid, misleading hint.
+        attributes: options.format ? { type: `image/${options.format}` } : {},
+      }),
+    );
+  },
+
+  // Default implementation copied from Astro's baseService
+  getHTMLAttributes(options: ImageTransform) {
+    const { targetWidth, targetHeight } = getTargetDimensions(options);
+    const {
+      src,
+      width,
+      height,
+      format,
+      quality,
+      densities,
+      widths,
+      formats,
+      layout,
+      priority,
+      fit,
+      position,
+      ...attributes
+    } = options;
+
+    return {
+      ...attributes,
+      width: targetWidth,
+      height: targetHeight,
+      loading: attributes.loading ?? 'lazy',
+      decoding: attributes.decoding ?? 'async',
+    };
+  },
+};
+
+export default cloudflareLoader;

package/dist/frameworks/astro/templates/v5/wrangler.json

@@ -0,0 +1,6 @@
+{
+  "name": "cosmic-builder-dry-run",
+  "main": "dist/_worker.js/index.js",
+  "compatibility_date": "2025-03-03",
+  "compatibility_flags": ["nodejs_compat"]
+}

package/dist/frameworks/astro/templates/v6/astro.config.mjs.template

@@ -0,0 +1,35 @@
+// Generated by the Webflow Cloud builder. Merge logic lives in ./astro.config.webflow.ts.
+import { defineConfig } from 'astro/config';
+import { readFileSync } from 'node:fs';
+import cloudflare from '@astrojs/cloudflare';
+import react from '@astrojs/react';
+import userConfig from './clouduser.astro.config';
+import { withWebflowOverrides } from './astro.config.webflow';
+
+// Detect React 19+ so we know whether to alias react-dom/server -> .edge.
+let isReact19 = false;
+try {
+  const pkg = JSON.parse(readFileSync('./package.json', 'utf8'));
+  const reactVersion = pkg.dependencies?.react || pkg.devDependencies?.react || '';
+  // Match versions like "19", "^19", "~19", "19.0.0", "^19.0.0", etc.
+  isReact19 = /(?:^|[^\d])19(?:\.|$)/.test(reactVersion);
+} catch {
+  // Could not read package.json, assume not React 19.
+}
+
+export default defineConfig(
+  withWebflowOverrides(userConfig, {
+    mountPath: '${COSMIC_MOUNT_PATH}',
+    deployUrl: '${COSMIC_DEPLOY_URL}',
+    adapter: cloudflare({
+      imageService: 'custom',
+      // Note: platformProxy removed in Astro 6+ — workerd runs natively via @cloudflare/vite-plugin.
+    }),
+    reactIntegration: react(),
+    // Only React 19+ has react-dom/server.edge. React 18 has only .browser, which doesn't run in edge runtimes.
+    reactDomServerAlias:
+      import.meta.env.PROD && isReact19
+        ? { 'react-dom/server': 'react-dom/server.edge' }
+        : undefined,
+  }),
+);

package/dist/frameworks/astro/templates/v6/webflow-loader.ts

@@ -0,0 +1,126 @@
+/**
+ * Webflow Image Loader for Astro 6
+ *
+ * A custom Astro image service that resizes images on demand through
+ * Cloudflare's zone-level Image Resizing (`/cdn-cgi/image/...`). URL-building
+ * and responsive-width logic live in the framework-agnostic ./webflow-image-url
+ * helper (unit-tested); this file is the thin Astro-typed glue. Same loader as
+ * Astro 5 and 7.
+ *
+ * We set the adapter's imageService to 'custom' to keep resizing on the zone
+ * endpoint rather than the Worker Images binding.
+ */
+
+import type { ExternalImageService, ImageTransform, AstroConfig } from 'astro';
+import { normalizeSrc, isRemote, buildImageUrl, computeSrcSetWidths } from './webflow-image-url';
+
+// Default implementation copied from Astro's baseService
+function getTargetDimensions(options: ImageTransform) {
+  let targetWidth = options.width;
+  let targetHeight = options.height;
+
+  // For ESM imported images, calculate missing dimensions based on aspect ratio
+  if (typeof options.src === 'object' && 'width' in options.src && 'height' in options.src) {
+    const aspectRatio = options.src.width / options.src.height;
+    if (targetHeight && !targetWidth) {
+      targetWidth = Math.round(targetHeight * aspectRatio);
+    } else if (targetWidth && !targetHeight) {
+      targetHeight = Math.round(targetWidth / aspectRatio);
+    } else if (!targetWidth && !targetHeight) {
+      targetWidth = options.src.width;
+      targetHeight = options.src.height;
+    }
+  }
+
+  return {
+    targetWidth,
+    targetHeight,
+  };
+}
+
+const cloudflareLoader: ExternalImageService = {
+  getURL(options: ImageTransform, imageConfig: AstroConfig['image']) {
+    const { deployUrl, mountPath } = imageConfig.service.config;
+    const normalizedSrc = normalizeSrc(
+      typeof options.src === 'object' ? options.src.src : options.src,
+      deployUrl,
+      mountPath,
+    );
+    const isSvg =
+      typeof options.src === 'object' ? options.src.format === 'svg' : options.src.endsWith('.svg');
+
+    return buildImageUrl(
+      normalizedSrc,
+      {
+        width: options.width,
+        height: options.height,
+        quality: options.quality,
+        format: options.format,
+      },
+      deployUrl,
+      isSvg,
+    );
+  },
+
+  // Responsive variants. Astro resolves each entry's URL by calling getURL on
+  // its `transform`, so format=auto (set in getURL) flows through here too.
+  getSrcSet(options: ImageTransform, imageConfig: AstroConfig['image']) {
+    // Mirror getURL's passthrough: remote and SVG sources are not resized, so a
+    // srcset of identical URLs would be misleading markup. Normalize first, as
+    // getURL does, since build.assetsPrefix makes local asset srcs absolute on
+    // the deploy origin.
+    const { deployUrl, mountPath } = imageConfig.service.config;
+    const srcString = typeof options.src === 'object' ? options.src.src : options.src;
+    const normalizedSrc = normalizeSrc(srcString, deployUrl, mountPath);
+    const isSvg =
+      typeof options.src === 'object' ? options.src.format === 'svg' : srcString.endsWith('.svg');
+    if (isSvg || isRemote(normalizedSrc)) {
+      return [];
+    }
+
+    const { targetWidth, targetHeight } = getTargetDimensions(options);
+    const maxWidth =
+      typeof options.src === 'object' && 'width' in options.src ? options.src.width : undefined;
+
+    return computeSrcSetWidths(options, targetWidth, targetHeight, maxWidth).map(
+      ({ width, height, descriptor }) => ({
+        transform: { ...options, width, height },
+        descriptor,
+        // Only advertise a MIME type when a concrete format was requested. With
+        // the default (format=auto) Cloudflare negotiates the output, so
+        // `type: "image/auto"` would be an invalid, misleading hint.
+        attributes: options.format ? { type: `image/${options.format}` } : {},
+      }),
+    );
+  },
+
+  // Default implementation copied from Astro's baseService
+  getHTMLAttributes(options: ImageTransform) {
+    const { targetWidth, targetHeight } = getTargetDimensions(options);
+    const {
+      src,
+      width,
+      height,
+      format,
+      quality,
+      densities,
+      widths,
+      formats,
+      layout,
+      priority,
+      fit,
+      position,
+      ...attributes
+    } = options;
+
+    return {
+      ...attributes,
+      width: targetWidth,
+      height: targetHeight,
+      loading: attributes.loading ?? 'lazy',
+      decoding: attributes.decoding ?? 'async',
+    };
+  },
+};
+
+export default cloudflareLoader;

package/dist/frameworks/astro/templates/v6/wrangler.json

@@ -0,0 +1,9 @@
+{
+  "name": "cosmic-builder-dry-run",
+  "main": "@astrojs/cloudflare/entrypoints/server",
+  "compatibility_date": "2025-03-03",
+  "compatibility_flags": ["nodejs_compat"],
+  "assets": {
+    "directory": "./dist/client"
+  }
+}

package/dist/frameworks/astro/templates/v7/astro.config.mjs.template

@@ -0,0 +1,34 @@
+// Generated by the Webflow Cloud builder. Merge logic lives in ./astro.config.webflow.ts.
+import { defineConfig } from 'astro/config';
+import { readFileSync } from 'node:fs';
+import cloudflare from '@astrojs/cloudflare';
+import react from '@astrojs/react';
+import userConfig from './clouduser.astro.config';
+import { withWebflowOverrides } from './astro.config.webflow';
+
+// Detect React 19+ so we know whether to alias react-dom/server -> .edge.
+let isReact19 = false;
+try {
+  const pkg = JSON.parse(readFileSync('./package.json', 'utf8'));
+  const reactVersion = pkg.dependencies?.react || pkg.devDependencies?.react || '';
+  // Match versions like "19", "^19", "~19", "19.0.0", "^19.0.0", etc.
+  isReact19 = /(?:^|[^\d])19(?:\.|$)/.test(reactVersion);
+} catch {
+  // Could not read package.json, assume not React 19.
+}
+
+export default defineConfig(
+  withWebflowOverrides(userConfig, {
+    mountPath: '${COSMIC_MOUNT_PATH}',
+    deployUrl: '${COSMIC_DEPLOY_URL}',
+    adapter: cloudflare({
+      imageService: 'custom',
+      // Note: platformProxy removed in Astro 6+ — workerd runs natively via @cloudflare/vite-plugin.
+    }),
+    reactIntegration: react(),
+    // Only React 19+ has react-dom/server.edge. React 18 has only .browser, which doesn't run in edge runtimes.
+    reactDomServerAlias: import.meta.env.PROD && isReact19
+      ? { 'react-dom/server': 'react-dom/server.edge' }
+      : undefined,
+  })
+);

package/dist/frameworks/astro/templates/v7/webflow-loader.ts

@@ -0,0 +1,125 @@
+/**
+ * Webflow Image Loader for Astro 7
+ *
+ * A custom Astro image service that resizes images on demand through
+ * Cloudflare's zone-level Image Resizing (`/cdn-cgi/image/...`). URL-building
+ * and responsive-width logic live in the framework-agnostic ./webflow-image-url
+ * helper (unit-tested); this file is the thin Astro-typed glue.
+ *
+ * Note: Astro 7 defaults to 'cloudflare-binding' for imageService, but we use
+ * 'custom' to keep resizing on the zone endpoint rather than the Worker binding.
+ */
+
+import type { ExternalImageService, ImageTransform, AstroConfig } from 'astro';
+import { normalizeSrc, isRemote, buildImageUrl, computeSrcSetWidths } from './webflow-image-url';
+
+// Default implementation copied from Astro's baseService
+function getTargetDimensions(options: ImageTransform) {
+  let targetWidth = options.width;
+  let targetHeight = options.height;
+
+  // For ESM imported images, calculate missing dimensions based on aspect ratio
+  if (typeof options.src === 'object' && 'width' in options.src && 'height' in options.src) {
+    const aspectRatio = options.src.width / options.src.height;
+    if (targetHeight && !targetWidth) {
+      targetWidth = Math.round(targetHeight * aspectRatio);
+    } else if (targetWidth && !targetHeight) {
+      targetHeight = Math.round(targetWidth / aspectRatio);
+    } else if (!targetWidth && !targetHeight) {
+      targetWidth = options.src.width;
+      targetHeight = options.src.height;
+    }
+  }
+
+  return {
+    targetWidth,
+    targetHeight,
+  };
+}
+
+const cloudflareLoader: ExternalImageService = {
+  getURL(options: ImageTransform, imageConfig: AstroConfig['image']) {
+    const { deployUrl, mountPath } = imageConfig.service.config;
+    const normalizedSrc = normalizeSrc(
+      typeof options.src === 'object' ? options.src.src : options.src,
+      deployUrl,
+      mountPath,
+    );
+    const isSvg =
+      typeof options.src === 'object' ? options.src.format === 'svg' : options.src.endsWith('.svg');
+
+    return buildImageUrl(
+      normalizedSrc,
+      {
+        width: options.width,
+        height: options.height,
+        quality: options.quality,
+        format: options.format,
+      },
+      deployUrl,
+      isSvg,
+    );
+  },
+
+  // Responsive variants. Astro resolves each entry's URL by calling getURL on
+  // its `transform`, so format=auto (set in getURL) flows through here too.
+  getSrcSet(options: ImageTransform, imageConfig: AstroConfig['image']) {
+    // Mirror getURL's passthrough: remote and SVG sources are not resized, so a
+    // srcset of identical URLs would be misleading markup. Normalize first, as
+    // getURL does, since build.assetsPrefix makes local asset srcs absolute on
+    // the deploy origin.
+    const { deployUrl, mountPath } = imageConfig.service.config;
+    const srcString = typeof options.src === 'object' ? options.src.src : options.src;
+    const normalizedSrc = normalizeSrc(srcString, deployUrl, mountPath);
+    const isSvg =
+      typeof options.src === 'object' ? options.src.format === 'svg' : srcString.endsWith('.svg');
+    if (isSvg || isRemote(normalizedSrc)) {
+      return [];
+    }
+
+    const { targetWidth, targetHeight } = getTargetDimensions(options);
+    const maxWidth =
+      typeof options.src === 'object' && 'width' in options.src ? options.src.width : undefined;
+
+    return computeSrcSetWidths(options, targetWidth, targetHeight, maxWidth).map(
+      ({ width, height, descriptor }) => ({
+        transform: { ...options, width, height },
+        descriptor,
+        // Only advertise a MIME type when a concrete format was requested. With
+        // the default (format=auto) Cloudflare negotiates the output, so
+        // `type: "image/auto"` would be an invalid, misleading hint.
+        attributes: options.format ? { type: `image/${options.format}` } : {},
+      }),
+    );
+  },
+
+  // Default implementation copied from Astro's baseService
+  getHTMLAttributes(options: ImageTransform) {
+    const { targetWidth, targetHeight } = getTargetDimensions(options);
+    const {
+      src,
+      width,
+      height,
+      format,
+      quality,
+      densities,
+      widths,
+      formats,
+      layout,
+      priority,
+      fit,
+      position,
+      ...attributes
+    } = options;
+
+    return {
+      ...attributes,
+      width: targetWidth,
+      height: targetHeight,
+      loading: attributes.loading ?? 'lazy',
+      decoding: attributes.decoding ?? 'async',
+    };
+  },
+};
+
+export default cloudflareLoader;

package/dist/frameworks/astro/templates/v7/wrangler.json

@@ -0,0 +1,9 @@
+{
+  "name": "cosmic-builder-dry-run",
+  "main": "@astrojs/cloudflare/entrypoints/server",
+  "compatibility_date": "2025-03-03",
+  "compatibility_flags": ["nodejs_compat"],
+  "assets": {
+    "directory": "./dist/client"
+  }
+}

package/dist/frameworks/astro/templates/webflow-image-url.ts

@@ -0,0 +1,140 @@
+// Pure helpers for Webflow Cloud's on-demand Cloudflare image URLs.
+//
+// Copied verbatim into the user's project (imported by webflow-loader.ts) and
+// unit-tested directly in @webflow/cloud-app. Deliberately free of any `astro`
+// import so it can be type-checked and tested without the framework installed;
+// the loader supplies the Astro-typed glue. Shared across Astro 5/6/7.
+
+export type ImageUrlOptions = {
+  width?: number;
+  height?: number;
+  quality?: number | string;
+  format?: string;
+};
+
+/**
+ * Rewrite an image src to a path relative to the deploy: add the mount path,
+ * drop the deploy URL, and remove the leading slash. Remote URLs are returned
+ * unchanged so the caller can detect and pass them through.
+ */
+export function normalizeSrc(src: string, deployUrl?: string, mountPath?: string): string {
+  // For local assets, include the mount path but not the deploy url, and remove the leading slash
+  if (deployUrl && src.startsWith(deployUrl)) {
+    return `${src.slice(deployUrl.length)}`.slice(1);
+  } else if (mountPath && src.startsWith(mountPath)) {
+    return src.slice(1);
+  } else if (src.startsWith('/')) {
+    return `${mountPath}${src}`.slice(1);
+  }
+  return src;
+}
+
+export function isRemote(normalizedSrc: string): boolean {
+  return normalizedSrc.startsWith('http://') || normalizedSrc.startsWith('https://');
+}
+
+/**
+ * Build the on-demand Cloudflare Image Resizing URL (`/cdn-cgi/image/...`) for a
+ * local asset. Remote images and SVGs, and requests with nothing to transform,
+ * are returned as the plain asset URL.
+ *
+ * When the caller pins no `format`, default to `auto` so Cloudflare negotiates
+ * WebP/AVIF (via the Accept header) instead of serving the heavier source
+ * format. An explicit `format` is honored as-is.
+ */
+export function buildImageUrl(
+  normalizedSrc: string,
+  options: ImageUrlOptions,
+  deployUrl: string,
+  isSvg: boolean,
+): string {
+  // Remote images are served as-is, never routed through Cloudflare resizing:
+  // our zone does not optimize external images, and re-optimizing Webflow-hosted
+  // images (cdn.website-files.com) would double-bill bandwidth (the origin zone
+  // for the full image plus the cosmic zone for the resized one). Astro hands
+  // http(s) srcs straight through.
+  if (isRemote(normalizedSrc)) {
+    return normalizedSrc;
+  }
+
+  const params: string[] = [];
+  for (const key of ['width', 'height', 'quality'] as const) {
+    const value = options[key];
+    if (value) {
+      params.push(`${key}=${value}`);
+    }
+  }
+
+  // Only route through /cdn-cgi/image when there is something to transform. An
+  // explicit format alone still counts (e.g. `<Image format="webp" />`).
+  const transforming = params.length > 0 || Boolean(options.format);
+  if (isSvg || !transforming) {
+    return `${deployUrl}/${normalizedSrc}`;
+  }
+
+  params.push(`format=${options.format || 'auto'}`);
+  return `${deployUrl}/cdn-cgi/image/${params.join(',')}/${normalizedSrc}`;
+}
+
+export type SrcSetWidth = { width: number; height?: number; descriptor: string };
+
+/**
+ * Compute the responsive variants Astro's `<Image>` asked for, mirroring
+ * Astro's own baseService: `densities` yield `Nx` descriptors, `widths` yield
+ * `Nw` descriptors. Each width's height is derived from the target aspect ratio.
+ * Variants are de-duplicated and kept within `maxWidth` (the source's intrinsic
+ * width, when known): `widths` above it are clamped, and `densities` that would
+ * resolve above it are dropped (matching Astro, which never upscales). Returns
+ * `[]` when no responsive variants were requested, so the loader can omit
+ * `srcset` entirely.
+ */
+export function computeSrcSetWidths(
+  options: { widths?: number[]; densities?: Array<number | string> },
+  targetWidth: number | undefined,
+  targetHeight: number | undefined,
+  maxWidth?: number,
+): SrcSetWidth[] {
+  if (!targetWidth) {
+    return [];
+  }
+
+  const aspectRatio = targetHeight ? targetWidth / targetHeight : undefined;
+  const heightFor = (w: number) => (aspectRatio ? Math.round(w / aspectRatio) : undefined);
+
+  if (options.densities?.length) {
+    const seen = new Set<number>();
+    const result: SrcSetWidth[] = [];
+    for (const d of options.densities) {
+      const density = typeof d === 'string' ? parseFloat(d) : d;
+      const width = Math.round(targetWidth * density);
+      // Drop densities that would upscale past the source's intrinsic width:
+      // Astro's baseService ignores them rather than clamping, so an `Nx`
+      // descriptor never ends up pointing at a smaller image.
+      if (maxWidth && width > maxWidth) {
+        continue;
+      }
+      if (seen.has(width)) {
+        continue;
+      }
+      seen.add(width);
+      result.push({ width, height: heightFor(width), descriptor: `${density}x` });
+    }
+    return result;
+  }
+
+  if (options.widths?.length) {
+    const seen = new Set<number>();
+    const result: SrcSetWidth[] = [];
+    for (const raw of options.widths) {
+      const width = maxWidth ? Math.min(raw, maxWidth) : raw;
+      if (seen.has(width)) {
+        continue;
+      }
+      seen.add(width);
+      result.push({ width, height: heightFor(width), descriptor: `${width}w` });
+    }
+    return result;
+  }
+
+  return [];
+}