Aadi

Generation Settings

AI chats 1

About

A settings panel for an image model with model, aspect ratio, count and advanced steps, guidance and seed, locked while it generates.

Built with React and Tailwind. Copy the prompt and paste it into Claude Code, Cursor or Lovable: your agent adds Generation Settings to your project and fits it to your theme.

Code

How Generation Settings is used: the demo's code. The component's own source comes with a free account.

Usage.tsx

"use client"

import * as React from "react"
import { cn } from "@/lib/utils"
import { Button, GenerationModel, GenerationSettings, GenerationSettingsValue, Icon, IconNode, Tooltip, createIcon } from "@/components/ui/generation-settings"

interface Run {
  prompt: string
  photo: { src: string; alt: string; width: number; height: number }
  settings: GenerationSettingsValue
}

// picsum.photos id 433, 640 x 800, 360 wide thumbnail, inline so the 21st preview needs no image host.
const bear = {
  alt: "Close portrait of a brown bear looking straight at the camera",
  width: 360,
  height: 450,
  src: "data:image/webp;base64,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",
}

// picsum.photos id 599, 800 x 600, inline so the 21st preview needs no image host.
const summit = {
  alt: "A mountain summit rising above a sea of low clouds",
  width: 800,
  height: 600,
  src: "data:image/webp;base64,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",
}

// picsum.photos id 64, 640 x 640, 360 wide thumbnail, inline so the 21st preview needs no image host.
const daisies = {
  alt: "A woman in sunglasses holding a bunch of daisies in a summer field",
  width: 360,
  height: 360,
  src: "data:image/webp;base64,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",
}

/** Three runs: each sets the panel, generates, and lands its image. */
const RUNS: Run[] = [
  {
    prompt: "Close portrait of a brown bear, soft overcast light, shallow depth of field",
    photo: bear,
    settings: {
      model: "lumen-2",
      count: 1,
      aspectRatio: "4:5",
      steps: 32,
      guidance: 4.5,
      seed: 2048117,
      seedLocked: false,
      negativePrompt: "",
    },
  },
  {
    prompt: "A mountain summit above a sea of low clouds at sunrise, wide and quiet",
    photo: summit,
    settings: {
      model: "lumen-2-fast",
      count: 1,
      aspectRatio: "4:3",
      steps: 8,
      guidance: 3,
      seed: 551902,
      seedLocked: false,
      negativePrompt: "",
    },
  },
  {
    prompt: "Summer field portrait, a woman holding daisies, warm film grain",
    photo: daisies,
    settings: {
      model: "prism-xl",
      count: 1,
      aspectRatio: "1:1",
      steps: 40,
      guidance: 6,
      seed: 90210417,
      seedLocked: true,
      negativePrompt: "",
    },
  },
]

const reducedMotion = () => window.matchMedia("(prefers-reduced-motion: reduce)").matches

/** Beats of one run: hold the finished image, change the settings, then generate. */
const HOLD_MS = 2600

const SET_MS = 1100

const TICK_MS = 120

const GEN_MS = 2600

const FIT_CSS = "html,body{overflow:hidden}[data-fit-small] [data-fit-hide]{display:none!important}"

/**
 * 21st shows a demo in a small frame: about 674 by 421 on a component page, 358 by 224 on a
 * phone and 245 by 139 on a profile card. A demo taller than its frame gets scrollbars, which
 * render white on dark pages. FitFrame fills the frame exactly instead.
 *
 * - "scale": the content shrinks until it fits, centered. For visuals such as orbs.
 * - "crop": the content stays at full size from the top and fades out at the bottom. For text
 *   that streams in, where a changing scale would make the page breathe.
 *
 * `minWidth` lays out a wide demo (a table, a two column panel) at that width and scales it down
 * to the frame, instead of letting it collapse to a narrow layout. The frame centers it, so it
 * shrinks evenly on both sides.
 *
 * Anything marked `data-fit-hide` (state buttons, the chatcn.dev line) drops out in frames
 * shorter than `hideBelow`, so a profile card shows the visual alone.
 */
function FitFrame({
  children,
  mode = "scale",
  hideBelow = 360,
  minWidth,
}: {
  children: React.ReactNode
  mode?: "scale" | "crop"
  hideBelow?: number
  minWidth?: string
}) {
  const content = React.useRef<HTMLDivElement>(null)
  const [cropped, setCropped] = React.useState(false)

  React.useLayoutEffect(() => {
    const el = content.current
    if (!el) return
    const measure = () => {
      const vw = window.innerWidth
      const vh = window.innerHeight
      el.toggleAttribute("data-fit-small", vh < hideBelow)
      // Layout sizes ignore the transform, so measuring never feeds back.
      const w = Math.max(el.offsetWidth, el.scrollWidth)
      const h = Math.max(el.offsetHeight, el.scrollHeight)
      const scale = mode === "scale" ? Math.min(1, vw / w, vh / h) : 1
      el.style.transform = scale < 1 ? `scale(${scale})` : ""
      setCropped(mode === "crop" && h > vh + 1)
    }
    measure()
    const observer = new ResizeObserver(measure)
    observer.observe(el)
    // Content that changes inside a fixed width box (a headline that cycles words) never resizes
    // the box itself, so changes below it measure again on the next frame.
    let frame = 0
    const mutations = new MutationObserver(() => {
      cancelAnimationFrame(frame)
      frame = requestAnimationFrame(measure)
    })
    mutations.observe(el, { subtree: true, childList: true, characterData: true })
    window.addEventListener("resize", measure)
    return () => {
      observer.disconnect()
      mutations.disconnect()
      cancelAnimationFrame(frame)
      window.removeEventListener("resize", measure)
    }
  }, [mode, hideBelow])

  const fade = "linear-gradient(to bottom, #000 calc(100% - 40px), transparent)"
  return (
    <div
      className="flex w-full justify-center overflow-hidden"
      style={{
        height: "100dvh",
        alignItems: mode === "crop" ? "flex-start" : "center",
        maskImage: cropped ? fade : undefined,
        WebkitMaskImage: cropped ? fade : undefined,
      }}
    >
      <style>{FIT_CSS}</style>
      <div
        ref={content}
        className="w-full shrink-0"
        style={{ transformOrigin: mode === "crop" ? "top center" : "center", minWidth }}
      >
        {children}
      </div>
    </div>
  )
}

/** Made up image models, so no real product is quoted. */
const MODELS: GenerationModel[] = [
  { id: "lumen-2", label: "Lumen 2", description: "Best detail, slower" },
  { id: "lumen-2-fast", label: "Lumen 2 Fast", description: "Drafts in seconds" },
  { id: "prism-xl", label: "Prism XL", description: "Strong on text and film looks" },
]

/* -------------------------------------------------------------------------------------------------
 * Types
 * -----------------------------------------------------------------------------------------------*/

type ImageLoaderStatus = "queued" | "generating" | "done" | "error"

/**
 * How the placeholder resolves into the image.
 * - `denoise`: coarse monochrome noise that gets finer step by step, like a diffusion preview.
 * - `mosaic`: a grid of small rounded squares that settle from coarse to fine blocks.
 * - `scan`: a soft edge travels down; finished image above it, a dithered preview below.
 */
type ImageLoaderVariant = "denoise" | "mosaic" | "scan"

/** `"3:2"`, `"9:16"`, or a number (width over height). */
type ImageLoaderAspectRatio = `${number}:${number}` | number

interface ImageLoaderProps extends Omit<React.ComponentProps<"div">, "children"> {
  /**
   * The image. Optional until `status` is `done`. While generating, pass a partial image from the
   * provider here and the placeholder resolves into it.
   */
  src?: string
  /** Describes the finished image. */
  alt: string
  status: ImageLoaderStatus
  /** Default `denoise`. */
  variant?: ImageLoaderVariant
  /** 0 to 1. Leave it out when the provider reports nothing: the placeholder runs indeterminate. */
  progress?: number
  /** Default 1. Sets the frame from the first paint, so nothing shifts when the image lands. */
  aspectRatio?: ImageLoaderAspectRatio
  /** Place in line while queued. 1 means next. */
  queuePosition?: number
  /** Seconds left, when the provider estimates it. */
  eta?: number
  /** Why it failed and what to do. Shown on frames 240 px and wider. */
  error?: React.ReactNode
  onRetry?: () => void
  onCancel?: () => void
  /** Seeds the placeholder pattern, so a grid of loaders does not look identical. Default 1. */
  seed?: number
  /** Intrinsic size of the finished image, passed to the `<img>`. */
  width?: number
  height?: number
}

/* -------------------------------------------------------------------------------------------------
 * Helpers
 * -----------------------------------------------------------------------------------------------*/

function parseRatio(ratio: ImageLoaderAspectRatio | undefined): number {
  if (typeof ratio === "number") return ratio > 0 ? ratio : 1
  if (!ratio) return 1
  const [w, h] = ratio.split(":").map(Number)
  return w && h && w > 0 && h > 0 ? w / h : 1
}

/* -------------------------------------------------------------------------------------------------
 * Image loading for the canvas
 * -----------------------------------------------------------------------------------------------*/

/** Decodes `src` off-DOM for the canvas. Returns the element once it can be drawn. */
function useDecodedImage(src: string | undefined) {
  const [state, setState] = React.useState<{
    src?: string
    img: HTMLImageElement | null
    failed: boolean
  }>({ img: null, failed: false })
  React.useEffect(() => {
    if (!src) return
    let alive = true
    const img = new Image()
    img.decoding = "async"
    img.onload = () => {
      if (alive) setState({ src, img, failed: false })
    }
    img.onerror = () => {
      if (alive) setState({ src, img: null, failed: true })
    }
    img.src = src
    return () => {
      alive = false
      img.onload = null
      img.onerror = null
    }
  }, [src])
  if (!src) return { img: null, ready: false, failed: false }
  // Keep the previous partial image on screen until the next one has decoded.
  const current = state.src === src
  return { img: state.img, ready: current && !state.failed, failed: current && state.failed }
}

const clamp01 = (n: number) => Math.min(1, Math.max(0, n))

/* -------------------------------------------------------------------------------------------------
 * Painter: everything the canvas needs, created once per mount
 *
 * Colors come from the theme tokens at runtime: each `--chatcn-*` value is painted into a 1 px
 * probe canvas and read back as RGB, so any color format the browser knows works, and a scoped
 * theme on a parent element is respected. The finished image is only ever drawn, never read
 * back, so cross-origin images without CORS headers work too.
 * -----------------------------------------------------------------------------------------------*/

type Rgb = readonly [number, number, number]

interface Palette {
  /** The frame fill, `--chatcn-fill`. */
  base: Rgb
  /** Dark end of the noise in light mode, `--chatcn-fill-active`. */
  lo: Rgb
  /** Light end, `--chatcn-fg-faint`. */
  hi: Rgb
  hiCss: string
  baseCss: string
}

interface Painter {
  canvas: HTMLCanvasElement
  ctx: CanvasRenderingContext2D
  /** Device px. */
  w: number
  h: number
  dpr: number
  palette: Palette
  /** Smooth value noise, FIELD x FIELD, 0 to 1: the composition the placeholder settles into. */
  field: Float32Array
  /** Small buffers for noise, dither and downsampled images. */
  small: HTMLCanvasElement
  smallCtx: CanvasRenderingContext2D
  /** Full-size layers for masking and mosaic crossfades. */
  layer: HTMLCanvasElement
  layerCtx: CanvasRenderingContext2D
  prev: HTMLCanvasElement
  prevCtx: CanvasRenderingContext2D
  /** Cached dither for the scan variant, keyed by size and palette. */
  dither?: { key: string; canvas: HTMLCanvasElement }
  mosaic: { level: number; prev: number; changedAt: number; key: string }
  /** Queued: the same pattern at low contrast, so waiting reads quieter than working. */
  calm: boolean
}

function context(canvas: HTMLCanvasElement) {
  const ctx = canvas.getContext("2d")
  if (!ctx) throw new Error("ImageLoader needs a 2D canvas context.")
  return ctx
}

function offscreen() {
  const canvas = document.createElement("canvas")
  canvas.width = 1
  canvas.height = 1
  return { canvas, ctx: context(canvas) }
}

function hex(c: Rgb) {
  return `#${c.map((v) => Math.round(v).toString(16).padStart(2, "0")).join("")}`
}

function readPalette(el: Element): Palette {
  const probe = document.createElement("canvas")
  probe.width = 1
  probe.height = 1
  const ctx = probe.getContext("2d", { willReadFrequently: true })
  const style = getComputedStyle(el)
  const read = (name: string, fallback: Rgb): Rgb => {
    const value = style.getPropertyValue(name).trim()
    if (!ctx || !value) return fallback
    ctx.clearRect(0, 0, 1, 1)
    ctx.fillStyle = "black"
    ctx.fillStyle = value
    ctx.fillRect(0, 0, 1, 1)
    const d = ctx.getImageData(0, 0, 1, 1).data
    return [d[0] ?? 0, d[1] ?? 0, d[2] ?? 0]
  }
  const base = read("--chatcn-fill", [247, 247, 247])
  const hi = read("--chatcn-fg-faint", [160, 160, 160])
  return {
    base,
    lo: read("--chatcn-fill-active", [232, 232, 232]),
    hi,
    hiCss: hex(hi),
    baseCss: hex(base),
  }
}

/** Small seeded PRNG (mulberry32): same seed, same pattern. */
function rng(seed: number) {
  let a = seed >>> 0
  return () => {
    a = (a + 0x6d2b79f5) >>> 0
    let t = a
    t = Math.imul(t ^ (t >>> 15), t | 1)
    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
  }
}

const FIELD = 96

const lerp = (a: number, b: number, t: number) => a + (b - a) * t

/** Two octaves of smoothed value noise, contrast stretched to 0..1. */
function makeField(seed: number) {
  const rand = rng(seed * 7919 + 17)
  const lattice = (n: number) => Array.from({ length: (n + 1) * (n + 1) }, rand)
  const octaves = [
    { n: 4, a: lattice(4), w: 0.7 },
    { n: 9, a: lattice(9), w: 0.3 },
  ]
  const smooth = (t: number) => t * t * (3 - 2 * t)
  const out = new Float32Array(FIELD * FIELD)
  let min = 1
  let max = 0
  for (let y = 0; y < FIELD; y++) {
    for (let x = 0; x < FIELD; x++) {
      let v = 0
      for (const { n, a, w } of octaves) {
        const fx = (x / FIELD) * n
        const fy = (y / FIELD) * n
        const ix = Math.floor(fx)
        const iy = Math.floor(fy)
        const tx = smooth(fx - ix)
        const ty = smooth(fy - iy)
        const at = (i: number, j: number) => a[j * (n + 1) + i] ?? 0
        const top = lerp(at(ix, iy), at(ix + 1, iy), tx)
        const bottom = lerp(at(ix, iy + 1), at(ix + 1, iy + 1), tx)
        v += lerp(top, bottom, ty) * w
      }
      out[y * FIELD + x] = v
      if (v < min) min = v
      if (v > max) max = v
    }
  }
  const range = max - min || 1
  for (let i = 0; i < out.length; i++) out[i] = ((out[i] ?? 0) - min) / range
  return out
}

function createPainter(canvas: HTMLCanvasElement, seed: number): Painter {
  const small = offscreen()
  const layer = offscreen()
  const prev = offscreen()
  return {
    canvas,
    ctx: context(canvas),
    w: 0,
    h: 0,
    dpr: 1,
    palette: readPalette(canvas),
    field: makeField(seed),
    small: small.canvas,
    smallCtx: small.ctx,
    layer: layer.canvas,
    layerCtx: layer.ctx,
    prev: prev.canvas,
    prevCtx: prev.ctx,
    mosaic: { level: -1, prev: -1, changedAt: 0, key: "" },
    calm: false,
  }
}

/* -------------------------------------------------------------------------------------------------
 * ImageLoader
 * -----------------------------------------------------------------------------------------------*/

const REVEAL_MS = 420

const easeOut = (t: number) => 1 - (1 - t) ** 3

const FRAME_MS = 33

const BOIL_MS = 100

/* --- mosaic --------------------------------------------------------------------------------- */

/** Squares across the short side, coarse to fine. Cells never get smaller than 4 CSS px. */
function mosaicLevels(shortCss: number) {
  const levels = [3, 4, 6, 8, 12, 16, 24, 32, 44].filter((n) => shortCss / n >= 4)
  return levels.length ? levels : [3]
}

function resize(canvas: HTMLCanvasElement, w: number, h: number) {
  if (canvas.width !== w) canvas.width = w
  if (canvas.height !== h) canvas.height = h
}

function fillBase(p: Painter) {
  const { ctx, w, h } = p
  ctx.globalAlpha = 1
  ctx.globalCompositeOperation = "source-over"
  ctx.fillStyle = p.palette.baseCss
  ctx.fillRect(0, 0, w, h)
}

/** Draws `img` into the rect with `object-fit: cover`. */
function drawCover(
  ctx: CanvasRenderingContext2D,
  img: HTMLImageElement,
  dx: number,
  dy: number,
  dw: number,
  dh: number,
) {
  const iw = img.naturalWidth || dw
  const ih = img.naturalHeight || dh
  const scale = Math.max(dw / iw, dh / ih)
  const sw = dw / scale
  const sh = dh / scale
  ctx.drawImage(img, (iw - sw) / 2, (ih - sh) / 2, sw, sh, dx, dy, dw, dh)
}

function squaresPath(
  ctx: CanvasRenderingContext2D,
  w: number,
  h: number,
  cols: number,
  dpr: number,
  each?: (x: number, y: number, size: number, cx: number, cy: number) => void,
) {
  const short = Math.min(w, h)
  const size = short / cols
  const nx = Math.ceil(w / size)
  const ny = Math.ceil(h / size)
  const ox = (w - nx * size) / 2
  const oy = (h - ny * size) / 2
  const gap = Math.max(dpr, size * 0.12)
  const side = size - gap
  const radius = Math.max(dpr, side * 0.26)
  for (let y = 0; y < ny; y++) {
    for (let x = 0; x < nx; x++) {
      const sx = ox + x * size + gap / 2
      const sy = oy + y * size + gap / 2
      if (each) {
        ctx.beginPath()
        each(x, y, side, (sx + side / 2) / w, (sy + side / 2) / h)
      }
      if (ctx.roundRect) ctx.roundRect(sx, sy, side, side, radius)
      else ctx.rect(sx, sy, side, side)
      if (each) ctx.fill()
    }
  }
  return { nx, ny }
}

const sample = (field: Float32Array, u: number, v: number) =>
  field[
    Math.min(FIELD - 1, Math.floor(clamp01(v) * FIELD)) * FIELD +
      Math.min(FIELD - 1, Math.floor(clamp01(u) * FIELD))
  ] ?? 0

/** One mosaic level into `target`, full size. */
function paintMosaicLevel(
  p: Painter,
  target: CanvasRenderingContext2D,
  img: HTMLImageElement | null,
  cols: number,
  now: number,
  live: boolean,
) {
  const { w, h, dpr, palette } = p
  target.globalAlpha = 1
  target.globalCompositeOperation = "source-over"
  target.clearRect(0, 0, w, h)
  if (img) {
    const short = Math.min(w, h)
    const size = short / cols
    // Blocks of the image, one color per square, then cut to rounded squares.
    const nx = Math.ceil(w / size)
    const ny = Math.ceil(h / size)
    resize(p.small, nx, ny)
    p.smallCtx.imageSmoothingEnabled = true
    p.smallCtx.imageSmoothingQuality = "high"
    drawCover(p.smallCtx, img, 0, 0, nx, ny)
    target.imageSmoothingEnabled = false
    target.drawImage(
      p.small,
      0,
      0,
      nx,
      ny,
      (w - nx * size) / 2,
      (h - ny * size) / 2,
      nx * size,
      ny * size,
    )
    target.globalCompositeOperation = "destination-in"
    target.fillStyle = palette.baseCss
    target.beginPath()
    squaresPath(target, w, h, cols, dpr)
    target.fill()
    target.globalCompositeOperation = "source-over"
    return
  }
  target.fillStyle = palette.hiCss
  const time = now / 1000
  squaresPath(target, w, h, cols, dpr, (x, y, _size, u, v) => {
    const hash = rng(x * 92821 + y * 68917 + cols * 7)()
    const twinkle = live ? 0.12 * Math.sin(time * 2.4 + hash * 6.283) : 0
    const value = 0.15 + 0.6 * sample(p.field, u, v) + 0.25 * (hash - 0.5) + twinkle
    target.globalAlpha = clamp01(value) * (p.calm ? 0.4 : 0.8)
  })
  target.globalAlpha = 1
}

function paintMosaic(
  p: Painter,
  img: HTMLImageElement | null,
  progress: number,
  now: number,
  indeterminate: boolean,
  live: boolean,
  animate: boolean,
) {
  const { ctx, w, h, dpr } = p
  const levels = mosaicLevels(Math.min(w, h) / dpr)
  const index = indeterminate
    ? Math.min(1, levels.length - 1)
    : Math.min(levels.length - 1, Math.floor(progress * levels.length))
  const state = p.mosaic
  const key = `${w}x${h}`
  if (state.key !== key) {
    state.key = key
    state.level = index
    state.prev = -1
  }
  if (index !== state.level) {
    state.prev = animate ? state.level : -1
    state.level = index
    state.changedAt = now
  }
  const settle = state.prev < 0 ? 1 : easeOut(clamp01((now - state.changedAt) / 240))
  if (settle >= 1) state.prev = -1

  resize(p.layer, w, h)
  resize(p.prev, w, h)
  fillBase(p)
  if (state.prev >= 0) {
    paintMosaicLevel(p, p.prevCtx, img, levels[state.prev] ?? 3, now, live)
    ctx.globalAlpha = 1 - settle
    ctx.drawImage(p.prev, 0, 0)
  }
  paintMosaicLevel(p, p.layerCtx, img, levels[index] ?? 3, now, live)
  ctx.globalAlpha = settle
  ctx.drawImage(p.layer, 0, 0)
  ctx.globalAlpha = 1
}

/** The image at a reduced resolution, upscaled. `smooth` blurs it, otherwise it pixelates. */
function drawLowRes(
  p: Painter,
  target: CanvasRenderingContext2D,
  img: HTMLImageElement,
  shortSide: number,
  smooth: boolean,
) {
  const short = Math.min(p.w, p.h)
  const rw = Math.max(1, Math.round((shortSide * p.w) / short))
  const rh = Math.max(1, Math.round((shortSide * p.h) / short))
  resize(p.small, rw, rh)
  p.smallCtx.imageSmoothingEnabled = true
  p.smallCtx.imageSmoothingQuality = "high"
  drawCover(p.smallCtx, img, 0, 0, rw, rh)
  target.imageSmoothingEnabled = smooth
  target.imageSmoothingQuality = "high"
  target.drawImage(p.small, 0, 0, rw, rh, 0, 0, p.w, p.h)
}

const BAYER = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5]

/* --- scan ----------------------------------------------------------------------------------- */

const DITHER_ALPHA = 0.78

/** Ordered 1-bit dither of the field in token grays. Cached: it only changes with size or theme. */
function ditherCanvas(p: Painter) {
  const { w, h, dpr, palette } = p
  const key = `${w}x${h}:${palette.hiCss}:${palette.baseCss}`
  if (p.dither?.key === key) return p.dither.canvas
  const cell = Math.max(dpr * 2, Math.min(w, h) / 256)
  const nw = Math.ceil(w / cell)
  const nh = Math.ceil(h / cell)
  const canvas = p.dither?.canvas ?? document.createElement("canvas")
  resize(canvas, nw, nh)
  const ctx = context(canvas)
  const data = ctx.createImageData(nw, nh)
  const px = data.data
  const { hi } = palette
  for (let y = 0; y < nh; y++) {
    for (let x = 0; x < nw; x++) {
      const threshold = ((BAYER[(y % 4) * 4 + (x % 4)] ?? 0) + 0.5) / 16
      const v = 0.12 + 0.62 * sample(p.field, x / nw, y / nh)
      const i = (y * nw + x) * 4
      px[i] = hi[0]
      px[i + 1] = hi[1]
      px[i + 2] = hi[2]
      px[i + 3] = v > threshold ? Math.round(DITHER_ALPHA * 255) : 0
    }
  }
  ctx.putImageData(data, 0, 0)
  p.dither = { key, canvas }
  return canvas
}

const SCAN_LOOP_MS = 2400

function paintScan(
  p: Painter,
  img: HTMLImageElement | null,
  progress: number,
  now: number,
  indeterminate: boolean,
) {
  const { ctx, w, h, dpr, palette } = p
  const short = Math.min(w, h)
  fillBase(p)

  // Below the edge: the fine preview.
  if (img) drawLowRes(p, ctx, img, Math.max(8, Math.round(short / dpr / 5)), false)
  else {
    const dither = ditherCanvas(p)
    ctx.imageSmoothingEnabled = false
    ctx.drawImage(dither, 0, 0, dither.width, dither.height, 0, 0, w, h)
  }

  // Above the edge: the resolved layer, faded out across a soft edge.
  resize(p.layer, w, h)
  const layer = p.layerCtx
  layer.globalCompositeOperation = "source-over"
  layer.globalAlpha = 1
  layer.clearRect(0, 0, w, h)
  if (img) {
    layer.imageSmoothingEnabled = true
    layer.imageSmoothingQuality = "high"
    drawCover(layer, img, 0, 0, w, h)
  } else {
    const n = 48
    resize(p.small, n, n)
    const data = p.smallCtx.createImageData(n, n)
    const { hi, base } = palette
    for (let y = 0; y < n; y++) {
      for (let x = 0; x < n; x++) {
        // The continuous-tone version of the dither below: same field, same average density.
        const v = (0.12 + 0.62 * sample(p.field, x / n, y / n)) * DITHER_ALPHA
        const i = (y * n + x) * 4
        data.data[i] = lerp(base[0], hi[0], v)
        data.data[i + 1] = lerp(base[1], hi[1], v)
        data.data[i + 2] = lerp(base[2], hi[2], v)
        data.data[i + 3] = 255
      }
    }
    p.smallCtx.putImageData(data, 0, 0)
    layer.imageSmoothingEnabled = true
    layer.imageSmoothingQuality = "high"
    layer.drawImage(p.small, 0, 0, n, n, 0, 0, w, h)
  }

  const feather = Math.max(20 * dpr, h * 0.12)
  layer.globalCompositeOperation = "destination-in"
  let edge: number
  if (indeterminate) {
    // A band of resolved tone passes over the preview, leaves at the bottom, comes back at the top.
    const k = (now % SCAN_LOOP_MS) / SCAN_LOOP_MS
    edge = lerp(-feather, h + feather * 2, k)
    const g = layer.createLinearGradient(0, edge - feather * 2, 0, edge)
    g.addColorStop(0, "transparent")
    g.addColorStop(0.75, "black")
    g.addColorStop(1, "transparent")
    layer.fillStyle = g
  } else {
    edge = progress * (h + feather)
    const g = layer.createLinearGradient(0, edge - feather, 0, edge)
    g.addColorStop(0, "black")
    g.addColorStop(1, "transparent")
    layer.fillStyle = g
  }
  layer.fillRect(0, 0, w, h)
  layer.globalCompositeOperation = "source-over"
  ctx.drawImage(p.layer, 0, 0)

  // The edge itself: one quiet line where resolved meets preview.
  if (!indeterminate && progress > 0 && progress < 1) {
    const y = Math.round(edge - feather * 0.5)
    ctx.globalAlpha = 0.35
    ctx.fillStyle = palette.hiCss
    ctx.fillRect(0, y, w, Math.max(1, dpr))
    ctx.globalAlpha = 1
  }
}

/* --- denoise -------------------------------------------------------------------------------- */

const DENOISE_STEPS = 20

function paintDenoise(
  p: Painter,
  img: HTMLImageElement | null,
  progress: number,
  noiseSeed: number,
  indeterminate: boolean,
) {
  const { ctx, w, h, palette, dpr } = p
  // Diffusion runs in discrete steps; so does the preview.
  const t = indeterminate ? 0.3 : Math.floor(progress * DENOISE_STEPS) / DENOISE_STEPS
  const short = Math.min(w, h)
  fillBase(p)
  if (img) drawLowRes(p, ctx, img, Math.max(2, short * lerp(0.025, 1, t * t)), true)

  const amount = img ? (1 - t) ** 1.4 : 1
  if (amount < 0.01) return
  // Grain from about 1/14 of the frame down to one CSS pixel.
  const cell = Math.max(dpr, lerp(short / 14, dpr, t ** 0.4))
  const cap = img ? 384 : 256
  const nw = Math.min(cap, Math.ceil(w / cell))
  const nh = Math.min(cap, Math.ceil(h / cell))
  resize(p.small, nw, nh)
  const data = p.smallCtx.createImageData(nw, nh)
  const px = data.data
  const rand = rng(noiseSeed)
  // Without an image the noise is the picture: the smooth field emerges as steps go by.
  const structure = img ? 0 : 0.2 + 0.65 * t
  const alpha = Math.round((img ? amount * 0.9 : 1) * 255)
  const { lo, hi } = palette
  const contrast = p.calm ? 0.38 : 0.72
  for (let y = 0; y < nh; y++) {
    for (let x = 0; x < nw; x++) {
      const white = rand()
      const raw = structure ? lerp(white, sample(p.field, x / nw, y / nh), structure) : white
      // Keep the noise in the light half of the ramp: texture, not static.
      const v = 0.06 + raw * contrast
      const i = (y * nw + x) * 4
      px[i] = lo[0] + (hi[0] - lo[0]) * v
      px[i + 1] = lo[1] + (hi[1] - lo[1]) * v
      px[i + 2] = lo[2] + (hi[2] - lo[2]) * v
      px[i + 3] = alpha
    }
  }
  p.smallCtx.putImageData(data, 0, 0)
  ctx.imageSmoothingEnabled = false
  ctx.drawImage(p.small, 0, 0, nw, nh, 0, 0, w, h)
}

/** Mosaic needs frames only while squares settle or twinkle. */
const mosaicSettling = (p: Painter) => p.mosaic.prev >= 0

/** `8 s`, `1 min 20 s`. Non-breaking spaces keep the number with its unit. */
function formatEta(seconds: number) {
  const s = Math.max(0, Math.round(seconds))
  if (s < 60) return `${s} s`
  const m = Math.floor(s / 60)
  const rest = s % 60
  return rest ? `${m} min ${rest} s` : `${m} min`
}

/** Small chrome that sits on the frame: opaque surface, so it reads over any pattern or image. */
const CHIP =
  "bg-(color:--chatcn-surface) text-(color:--chatcn-fg) shadow-(--chatcn-shadow-xs) pointer-events-auto inline-flex h-6 items-center rounded-full"

const iconNode: IconNode = [
  ["path", {"d":"M3 12a9 9 0 1 0 18 0 9 9 0 1 0-18 0"}],
  ["path", {"d":"M12 6.75v4.26a1.75 1.75 0 0 0 .85 1.5l2.9 1.74"}],
]

const ClockIcon: Icon = /* @__PURE__ */ createIcon("clock", iconNode)

/**
 * The only shimmer in chatcn: a status label such as "Thinking". Static under reduced motion.
 * Pass `active={false}` to settle it into plain subtle text.
 */
function ShimmerText({
  active = true,
  className,
  ...props
}: React.ComponentProps<"span"> & { active?: boolean }) {
  return (
    <span
      data-slot="shimmer-text"
      className={cn("font-medium", active ? "chatcn-shimmer" : "text-(color:--chatcn-fg-subtle)", className)}
      {...props}
    />
  )
}

const iconNode2: IconNode = [
  ["path", {"d":"m6 6 12 12"}],
  ["path", {"d":"m18 6-3.88 3.88"}],
  ["path", {"d":"M9.88 14.12 6 18"}],
]

const XIcon: Icon = /* @__PURE__ */ createIcon("x", iconNode2)

/* -------------------------------------------------------------------------------------------------
 * Chrome
 * -----------------------------------------------------------------------------------------------*/

function LoaderStatus({
  status,
  percent,
  queuePosition,
  eta,
  onCancel,
}: {
  status: "queued" | "generating"
  percent?: number
  queuePosition?: number
  eta?: number
  onCancel?: () => void
}) {
  const queued = status === "queued"
  const valueText = queued
    ? queuePosition
      ? `Queued, position ${queuePosition}`
      : "Queued"
    : [
        percent !== undefined ? `${percent}%` : null,
        eta !== undefined ? `about ${formatEta(eta)} left` : null,
      ]
        .filter(Boolean)
        .join(", ") || "Generating"
  return (
    <>
      <span
        role="progressbar"
        aria-label={queued ? "Waiting to generate" : "Generating image"}
        aria-valuemin={0}
        aria-valuemax={100}
        aria-valuenow={queued ? undefined : percent}
        aria-valuetext={valueText}
        className="sr-only"
      />

      {/* Frames under 160 px: a 2 px progress line, or a clock while queued. */}
      <div aria-hidden="true" className="hidden @max-[159px]:contents">
        {queued ? (
          <span className={cn(CHIP, "absolute start-1.5 bottom-1.5 size-5 justify-center")}>
            <ClockIcon className="text-(color:--chatcn-fg-subtle) size-3" />
          </span>
        ) : percent !== undefined ? (
          <span className="bg-(color:--chatcn-alpha-300) absolute inset-x-0 bottom-0 h-0.5">
            <span
              className="bg-(color:--chatcn-accent) block h-full origin-left transition-transform duration-300 ease-linear motion-reduce:transition-none rtl:origin-right"
              style={{ transform: `scaleX(${percent / 100})` }}
            />
          </span>
        ) : null}
      </div>

      <div
        data-slot="image-loader-status"
        className="pointer-events-none absolute inset-x-0 bottom-0 flex items-end justify-between gap-2 p-2 @max-[159px]:hidden @min-[320px]:p-3"
      >
        <span
          aria-hidden="true"
          className={cn(CHIP, "text-[0.75rem]/[1rem] min-w-0 gap-1.5 ps-2 pe-2.5 tabular-nums")}
        >
          {queued ? (
            <>
              <ClockIcon className="text-(color:--chatcn-fg-subtle) size-3 shrink-0" />
              <span className="text-(color:--chatcn-fg-muted) font-medium">Queued</span>
              {queuePosition ? (
                <span className="text-(color:--chatcn-fg-subtle) truncate @max-[219px]:hidden">
                  Position {queuePosition}
                </span>
              ) : null}
            </>
          ) : (
            <>
              <ShimmerText className="truncate">Generating</ShimmerText>
              {percent !== undefined ? (
                <span className="text-(color:--chatcn-fg-subtle) shrink-0">{percent}%</span>
              ) : null}
              {eta !== undefined ? (
                <span className="text-(color:--chatcn-fg-subtle) shrink-0 @max-[259px]:hidden">
                  <span aria-hidden="true" className="me-1.5">
                    ·
                  </span>
                  <bdi>{formatEta(eta)} left</bdi>
                </span>
              ) : null}
            </>
          )}
        </span>
        {onCancel ? (
          <Tooltip content="Cancel">
            <Button
              size="icon-xs"
              aria-label="Cancel generation"
              onClick={onCancel}
              className={cn(
                CHIP,
                "text-(color:--chatcn-fg-muted) hover:bg-(color:--chatcn-surface) hover:text-(color:--chatcn-fg) size-6 pointer-coarse:size-11",
              )}
            >
              <XIcon />
            </Button>
          </Tooltip>
        ) : null}
      </div>
    </>
  )
}

const iconNode3: IconNode = [
  ["path", {"d":"M3 12a9 9 0 1 0 18 0 9 9 0 1 0-18 0"}],
  ["path", {"d":"m9 9 6 6"}],
  ["path", {"d":"m15 9-6 6"}],
]

const CircleXIcon: Icon = /* @__PURE__ */ createIcon("circle-x", iconNode3)

const iconNode4: IconNode = [
  ["path", {"d":"M5.49 17.46A8.5 8.5 0 1 0 6.54 5.49"}],
  ["path", {"d":"m8.21 8.65-2.94-.26a2 2 0 0 1-1.82-2.16l.26-2.94"}],
]

const RotateCcwIcon: Icon = /* @__PURE__ */ createIcon("rotate-ccw", iconNode4)

function LoaderError({ error, onRetry }: { error?: React.ReactNode; onRetry?: () => void }) {
  return (
    <div
      data-slot="image-loader-error"
      className="absolute inset-0 grid place-items-center overflow-hidden p-3 text-center"
    >
      <div className="flex max-w-72 flex-col items-center gap-1">
        <CircleXIcon
          aria-hidden="true"
          className={cn("text-(color:--chatcn-red) mb-1 size-5", onRetry && "@max-[159px]:hidden")}
        />
        <p className="text-[0.8125rem]/[1.25rem] text-(color:--chatcn-fg) font-medium text-balance @max-[159px]:sr-only">
          Generation failed
        </p>
        <p className="text-[0.75rem]/[1rem] text-(color:--chatcn-fg-muted) text-pretty @max-[239px]:sr-only">
          {error ?? "The image service stopped responding. Retry, or try again in a minute."}
        </p>
        {onRetry ? (
          <>
            <Button
              variant="outline"
              size="sm"
              onClick={onRetry}
              className="mt-2 @max-[159px]:hidden pointer-coarse:h-11"
            >
              <RotateCcwIcon />
              Retry
            </Button>
            <Button
              variant="outline"
              size="icon-sm"
              aria-label="Retry generation"
              onClick={onRetry}
              className="hidden @max-[159px]:inline-flex"
            >
              <RotateCcwIcon className="text-(color:--chatcn-red)" />
            </Button>
          </>
        ) : null}
      </div>
    </div>
  )
}

const iconNode5: IconNode = [
  ["path", {"d":"m3.5 3.5 17 17"}],
  ["path", {"d":"M6.64 3H18a3 3 0 0 1 3 3v11.36"}],
  ["path", {"d":"M17.36 21H6a3 3 0 0 1-3-3V6.64"}],
  ["path", {"d":"M13.75 8.5a1.75 1.75 0 1 0 3.5 0 1.75 1.75 0 1 0-3.5 0"}],
  ["path", {"d":"m6.25 18 1.94-1.94a1.5 1.5 0 0 1 2.12 0L12.25 18"}],
]

const ImageOffIcon: Icon = /* @__PURE__ */ createIcon("image-off", iconNode5)

/** A hairline drawn inside the frame so light images never bleed into the canvas. */
const HAIRLINE =
  "pointer-events-none absolute inset-0 rounded-[inherit] shadow-[inset_0_0_0_1px_var(--chatcn-alpha-400)] forced-colors:outline-solid forced-colors:outline-1"

/**
 * The frame an image generation renders into: a live placeholder while the model works, then the
 * reveal. One canvas, one animation loop, paused offscreen and in background tabs. The finished
 * image is a real `<img>`, so it stays sharp at any size and keeps its `alt`.
 */
function ImageLoader({
  src,
  alt,
  status,
  variant = "denoise",
  progress,
  aspectRatio = 1,
  queuePosition,
  eta,
  error,
  onRetry,
  onCancel,
  seed = 1,
  width,
  height,
  className,
  style,
  ...props
}: ImageLoaderProps) {
  const ratio = parseRatio(aspectRatio)
  const rootRef = React.useRef<HTMLDivElement>(null)
  const canvasRef = React.useRef<HTMLCanvasElement>(null)

  // Restored from history: already done on first render, so the image fades in with no reveal.
  const [instant, setInstant] = React.useState(() => status === "done")
  if (instant && status !== "done") setInstant(false)
  const [revealed, setRevealed] = React.useState(instant)
  if (revealed && status !== "done") setRevealed(false)

  const decoded = useDecodedImage(src)
  const [domImage, setDomImage] = React.useState<{ src?: string; ok: boolean | null }>({
    src,
    ok: null,
  })
  if (domImage.src !== src) setDomImage({ src, ok: null })
  const imgRef = React.useCallback(
    (img: HTMLImageElement | null) => {
      if (img?.complete && img.naturalWidth > 0) {
        setDomImage((s) => (s.src === src && s.ok !== true ? { src, ok: true } : s))
      }
    },
    [src],
  )

  const done = status === "done"
  const unavailable = done && (!src || decoded.failed || domImage.ok === false)
  const indeterminate = progress === undefined
  const percent = indeterminate ? undefined : Math.round(clamp01(progress) * 100)

  // Announce once per generation, on the reveal or the failure.
  const [message, setMessage] = React.useState("")
  const announced = React.useRef(false)
  React.useEffect(() => {
    if (status === "queued" || status === "generating") {
      announced.current = false
      setMessage("")
    } else if (status === "error" && !announced.current) {
      announced.current = true
      setMessage("Image generation failed")
    }
  }, [status])
  const finishReveal = React.useCallback(() => {
    setRevealed(true)
    if (!announced.current) {
      announced.current = true
      setMessage("Image ready")
    }
  }, [])

  // Latest props for the animation loop, which lives outside React renders.
  const live = React.useRef({
    status,
    progress,
    variant,
    img: decoded.img,
    ready: decoded.ready,
    finishReveal,
    canvasDone: instant,
  })
  live.current = {
    status,
    progress,
    variant,
    img: decoded.img,
    ready: decoded.ready,
    finishReveal,
    canvasDone: instant || revealed,
  }
  const kick = React.useRef<() => void>(() => {})

  React.useEffect(() => {
    const canvas = canvasRef.current
    const root = rootRef.current
    if (!canvas || !root) return
    const painter = createPainter(canvas, seed)
    const reducedQuery = window.matchMedia("(prefers-reduced-motion: reduce)")
    const display = { p: 0, last: 0, painted: 0, boiled: 0, noise: seed, revealAt: 0, from: 0 }
    let raf = 0
    let onscreen = true
    let usedImage = false

    const frame = (now: number) => {
      raf = 0
      const s = live.current
      if (s.canvasDone || painter.w === 0) return
      const reduced = reducedQuery.matches
      const active = s.status === "generating"
      const indet = s.progress === undefined
      const target = indet ? 0 : clamp01(s.progress ?? 0)
      const dt = display.last ? Math.min(100, now - display.last) : 16
      display.last = now

      let revealing = false
      if (s.status === "done") {
        if (!s.img || !s.ready) return
        if (reduced) {
          s.finishReveal()
          return
        }
        if (!display.revealAt) {
          display.revealAt = now
          // From a placeholder that never saw the image, start from a coarse step so it resolves.
          display.from = usedImage ? display.p : Math.min(display.p, 0.4)
        }
        const k = clamp01((now - display.revealAt) / REVEAL_MS)
        display.p = lerp(display.from, 1, easeOut(k))
        revealing = true
        if (k >= 1) {
          s.finishReveal()
          return
        }
      } else {
        if (display.revealAt) {
          // A new run in the same frame: start over from noise.
          display.revealAt = 0
          display.p = 0
          usedImage = false
        }
        if (s.status === "queued") display.p = 0
        else if (s.status === "generating") {
          // Ease toward the reported progress so jumps from the provider read as motion.
          display.p = reduced ? target : lerp(display.p, target, 1 - Math.exp(-dt / 180))
        }
      }

      const moving = active && !reduced
      if (!revealing && moving && now - display.painted < FRAME_MS) {
        raf = requestAnimationFrame(frame)
        return
      }
      display.painted = now
      if (moving && now - display.boiled >= BOIL_MS) {
        display.boiled = now
        display.noise = (display.noise * 16807 + 1) % 2147483647
      }
      if (s.img) usedImage = true
      painter.calm = s.status === "queued"
      const img = s.img
      const showIndet = active && indet && !revealing
      if (s.variant === "mosaic")
        paintMosaic(painter, img, display.p, now, showIndet, moving, !reduced)
      else if (s.variant === "scan") paintScan(painter, img, display.p, now, showIndet)
      else paintDenoise(painter, img, display.p, display.noise, showIndet)

      const easing = Math.abs(display.p - target) > 0.002
      const more =
        revealing ||
        (moving && (indet || s.variant !== "scan" || easing)) ||
        (!reduced && mosaicSettling(painter))
      if (more && onscreen && !document.hidden) raf = requestAnimationFrame(frame)
    }

    const request = () => {
      if (!raf) raf = requestAnimationFrame(frame)
    }
    kick.current = request

    const measure = () => {
      const rect = root.getBoundingClientRect()
      const dpr = Math.min(window.devicePixelRatio || 1, 2)
      const scale = Math.min(dpr, 2048 / Math.max(1, rect.width, rect.height))
      painter.dpr = scale
      painter.w = Math.max(0, Math.round(rect.width * scale))
      painter.h = Math.max(0, Math.round(rect.height * scale))
      resize(canvas, Math.max(1, painter.w), Math.max(1, painter.h))
      request()
    }
    measure()
    const resizeObserver = new ResizeObserver(measure)
    resizeObserver.observe(root)

    const intersection = new IntersectionObserver(([entry]) => {
      onscreen = entry?.isIntersecting ?? true
      if (onscreen) request()
    })
    intersection.observe(root)

    // Theme switches: class or attribute changes on <html> or <body>, or the OS scheme.
    const repaint = () => {
      painter.palette = readPalette(canvas)
      painter.dither = undefined
      request()
    }
    const themeObserver = new MutationObserver(repaint)
    for (const el of [document.documentElement, document.body]) {
      themeObserver.observe(el, {
        attributes: true,
        attributeFilter: ["class", "style", "data-theme"],
      })
    }
    const schemeQuery = window.matchMedia("(prefers-color-scheme: dark)")
    schemeQuery.addEventListener("change", repaint)
    reducedQuery.addEventListener("change", request)
    document.addEventListener("visibilitychange", request)

    return () => {
      if (raf) cancelAnimationFrame(raf)
      kick.current = () => {}
      resizeObserver.disconnect()
      intersection.disconnect()
      themeObserver.disconnect()
      schemeQuery.removeEventListener("change", repaint)
      reducedQuery.removeEventListener("change", request)
      document.removeEventListener("visibilitychange", request)
    }
    // The canvas mounts again when a restored image is generated anew, hence `instant`.
  }, [seed, instant])

  // Every prop change that alters the picture asks for a frame.
  // The loop reads props from a ref; these are only the triggers.
  React.useEffect(() => {
    kick.current()
  }, [status, progress, variant, decoded.img, revealed])

  // The canvas stays mounted after the reveal so it can fade out under the image.
  const showCanvas = !instant
  const showImage = done && Boolean(src) && !decoded.failed
  const imageVisible = instant ? domImage.ok === true : revealed && domImage.ok !== false

  return (
    <div
      ref={rootRef}
      data-slot="image-loader"
      data-loader-state={status}
      data-variant={variant}
      aria-busy={status === "queued" || status === "generating" || undefined}
      className={cn(
        "bg-(color:--chatcn-fill) rounded-(--chatcn-radius-lg) @container relative isolate w-full overflow-hidden",
        className,
      )}
      style={{ aspectRatio: ratio, ...style }}
      {...props}
    >
      {showCanvas ? (
        <canvas
          ref={canvasRef}
          data-slot="image-loader-canvas"
          // Out of flow even without styles, so resizing the bitmap never resizes the frame.
          style={{
            position: "absolute",
            inset: 0,
            width: "100%",
            height: "100%",
            pointerEvents: "none",
          }}
          className={cn(
            "absolute inset-0 size-full",
            "ease-(--chatcn-ease-out-soft) transition-opacity duration-300 motion-reduce:duration-150",
            revealed && "opacity-0",
            (status === "error" || unavailable) && "opacity-40",
          )}
        />
      ) : null}

      {showImage ? (
        <img
          ref={imgRef}
          src={src}
          alt={alt}
          width={width}
          height={height}
          draggable={false}
          decoding="async"
          onLoad={() => setDomImage((s) => (s.ok === true ? s : { src, ok: true }))}
          onError={() => setDomImage({ src, ok: false })}
          data-slot="image-loader-image"
          className={cn(
            "absolute inset-0 size-full object-cover select-none",
            "ease-(--chatcn-ease-out-soft) transition-opacity duration-300 motion-reduce:duration-150",
            imageVisible ? "opacity-100" : "opacity-0",
          )}
        />
      ) : null}

      {status === "queued" || status === "generating" ? (
        <LoaderStatus
          status={status}
          percent={percent}
          queuePosition={queuePosition}
          eta={eta}
          onCancel={onCancel}
        />
      ) : null}

      {status === "error" ? <LoaderError error={error} onRetry={onRetry} /> : null}

      {unavailable && status === "done" ? (
        <div className="text-(color:--chatcn-fg-subtle) absolute inset-0 flex flex-col items-center justify-center gap-2 p-3 text-center">
          <ImageOffIcon aria-hidden="true" className="size-5" />
          <span className="text-[0.75rem]/[1rem] @max-[159px]:sr-only">Image unavailable</span>
        </div>
      ) : null}

      <span aria-hidden="true" className={HAIRLINE} />
      <span aria-live="polite" className="sr-only">
        {message}
      </span>
    </div>
  )
}

/** The image column is 19.5rem wide and 16.5rem tall: the frame's width for a ratio. */
function frameWidth(ratio: string) {
  const [w, h] = ratio.split(":").map(Number)
  const r = w && h ? w / h : 1
  return Math.min(19.5, 16.5 * r)
}

/** The line under each 21st demo that points back to the kit. */
function MoreOn({ slug, children }: { slug: string; children: React.ReactNode }) {
  return (
    <p data-fit-hide className="text-[0.75rem]/[1rem] text-(color:--chatcn-fg-faint) text-center text-balance">
      {children}{" "}
      <a
        href={`https://chatcn.dev/docs/components/${slug}`}
        target="_blank"
        rel="noopener"
        className="text-(color:--chatcn-fg-subtle) hover:text-(color:--chatcn-fg) underline underline-offset-2"
      >
        chatcn.dev
      </a>
    </p>
  )
}

/**
 * An image tool: the settings panel beside the frame it shapes. The tour picks a model, an
 * aspect ratio and steps for each prompt, presses Generate, and the frame denoises into the
 * image while the panel stays locked. Change anything yourself and the tour stops.
 */
export default function GenerationSettingsPreview() {
  const [run, setRun] = React.useState(0)
  const [phase, setPhase] = React.useState<"done" | "set" | "generating">("done")
  const [progress, setProgress] = React.useState(0)
  const [settings, setSettings] = React.useState<GenerationSettingsValue>(RUNS[0]!.settings)
  const [touched, setTouched] = React.useState(false)
  const [manual, setManual] = React.useState({ generating: false, n: 0 })

  // The tour: done (hold) -> set (next run's settings, frame reshapes) -> generating -> done.
  React.useEffect(() => {
    if (touched || reducedMotion()) return
    if (phase === "done") {
      const id = window.setTimeout(() => {
        const next = (run + 1) % RUNS.length
        setRun(next)
        setSettings(RUNS[next]!.settings)
        setPhase("set")
      }, HOLD_MS)
      return () => window.clearTimeout(id)
    }
    if (phase === "set") {
      const id = window.setTimeout(() => {
        setProgress(0)
        setPhase("generating")
      }, SET_MS)
      return () => window.clearTimeout(id)
    }
    const id = window.setInterval(() => {
      setProgress((p) => {
        const next = p + TICK_MS / GEN_MS
        if (next >= 1) {
          window.clearInterval(id)
          setPhase("done")
          return 1
        }
        return next
      })
    }, TICK_MS)
    return () => window.clearInterval(id)
  }, [phase, run, touched])

  // A visitor's own Generate: a short run on the same image.
  React.useEffect(() => {
    if (!manual.generating) return
    const id = window.setTimeout(() => setManual((m) => ({ ...m, generating: false })), GEN_MS)
    return () => window.clearTimeout(id)
  }, [manual])

  const current = RUNS[run]!
  const generating = touched ? manual.generating : phase === "generating"
  const status = generating ? "generating" : phase === "set" && !touched ? "queued" : "done"

  return (
    <FitFrame minWidth="42rem">
      <div className="flex w-full flex-col items-center justify-center gap-4 p-6">
        <div className="grid w-full max-w-[40rem] grid-cols-[19rem_1fr] items-start gap-6">
          {/* Tall enough for the locked panel's extra line, so the frame never rescales. */}
          <div className="flex min-h-[20.5rem] flex-col gap-3">
            <GenerationSettings
              title="Image settings"
              models={MODELS}
              value={settings}
              onValueChange={(v) => {
                setTouched(true)
                setSettings(v)
              }}
              generating={generating}
            />
            <Button
              variant="solid"
              size="lg"
              disabled={generating}
              onClick={() => {
                setTouched(true)
                setManual((m) => ({ generating: true, n: m.n + 1 }))
              }}
            >
              {generating ? "Generating…" : "Generate image"}
            </Button>
          </div>
          <div className="flex min-w-0 flex-col gap-3">
            <p className="text-[0.8125rem]/[1.25rem] text-(color:--chatcn-fg-muted) min-h-[2.5rem] text-pretty">{current.prompt}</p>
            <div className="flex h-[16.5rem] items-center justify-center">
              <ImageLoader
                key={`${settings.aspectRatio}-${run}-${manual.n}`}
                variant="denoise"
                status={status}
                progress={generating && !touched ? progress : undefined}
                aspectRatio={settings.aspectRatio as `${number}:${number}`}
                seed={settings.seed % 997}
                src={status === "done" ? current.photo.src : undefined}
                width={current.photo.width}
                height={current.photo.height}
                alt={current.photo.alt}
                style={{ width: `${frameWidth(settings.aspectRatio)}rem` }}
              />
            </div>
          </div>
        </div>
        <MoreOn slug="generation-settings">Model, size, steps and seed for an image model. On</MoreOn>
      </div>
    </FitFrame>
  )
}

Dependencies

More by Aadi

View all
  • Audio Visualizer

    Audio Visualizer

    29
  • Stat Card

    Stat Card

    24
  • Dither Orb

    Dither Orb

    23
  • Voice Orb

    Voice Orb

    17
  • Waveform

    Waveform

    13
  • Message Feedback

    Message Feedback

    12
  • Agent Lanes

    Agent Lanes

    11
  • Voice Controls

    Voice Controls

    10

More in AI chats

View all
  • AI Actions

    AI Actions

    349
  • Aquarium Prompt

    Aquarium Prompt

    95
  • Generation Stats

    Generation Stats

  • Chat Bubble

    Chat Bubble

    202
  • Commit

    Commit

    36
  • Color Picker

    Color Picker

    190
  • Environment Variables

    Environment Variables

    27
  • Message With Header And Delivery Status

    Message With Header And Delivery Status

    57

Explore more

Part of chatcn — browse the full library on 21st.dev.