AI image pipeline with a 7-level fallback chain

// app/api/generate-insert/route.ts
export const maxDuration = 60; // Vercel Pro function ceiling

type Diagnostics = {
  pipeline: PipelineKind;
  editsOk: boolean;
  sceneOk: boolean;
  rembgOk: boolean;
  moderationBlocked: boolean;
  candidateScores: number[];
  subjectFitsInCrop: boolean;
  subjectVisiblePct: number;
  timings: Record<string, number>;
};

export async function POST(req: Request) {
  const t = phaseTimer();
  const { photo, prompt, promptApproach } = await req.json();

  // Parallel kickoff — don't wait for /edits to fail before starting /generations.
  // Both calls share a 240s AbortController so a hung Replicate call can't
  // pin the function past Vercel's 60s ceiling.
  const ac = new AbortController();
  const timer = setTimeout(() => ac.abort(), 240_000);

  const [editsResult, sceneResult] = await Promise.allSettled([
    callOpenAiEdits(photo, prompt, promptApproach, ac.signal),
    callOpenAiGeneration(prompt, ac.signal), // scene-only, no subject
  ]);
  clearTimeout(timer);
  t.mark("openai");

  const editsOk = editsResult.status === "fulfilled";
  const sceneOk = sceneResult.status === "fulfilled";
  const moderationBlocked =
    !editsOk && (editsResult as PromiseRejectedResult).reason?.code === "moderation";

  // Variance scoring on /edits candidates (we generate 1; the scoring
  // pass also tells us subject-fit before we commit to the cheap path).
  let editsCandidate: ScoredCandidate | null = null;
  if (editsOk) {
    editsCandidate = await scoreCandidate(editsResult.value);
  }
  const subjectFitsInCrop = editsCandidate?.subjectFitsInCrop ?? false;

  // Routing decision — seven paths, each handles a real failure mode
  // I observed in dev logs.
  let pipeline: PipelineKind;
  let composed: Buffer;
  if (editsOk && subjectFitsInCrop) {
    pipeline = "natural";
    composed = await variantCrop(editsCandidate!.image);
  } else if (editsOk && sceneOk) {
    pipeline = "composite";
    const cutout = await rembg(editsCandidate!.image);
    composed = await composite(sceneResult.value, cutout, { groundShadow: true });
  } else if (editsOk) {
    pipeline = "composite-gradient";
    const cutout = await rembg(editsCandidate!.image);
    composed = await composite(svgGradient(prompt), cutout, { groundShadow: true });
  } else if (editsOk /* but rembg failed */) {
    pipeline = "edits-cropped";
    composed = await variantCrop(editsCandidate!.image); // accept cutoff risk
  } else if (sceneOk) {
    pipeline = "composite-only";
    const cutout = await rembg(photo); // rembg the ORIGINAL photo
    composed = await composite(sceneResult.value, cutout, { groundShadow: true });
  } else if (await rembg(photo).catch(() => null)) {
    pipeline = "rembg-gradient";
    const cutout = await rembg(photo);
    composed = await composite(svgGradient(prompt), cutout, { groundShadow: true });
  } else {
    return Response.json(
      { error: "Generation failed", diagnostics: { /* … */ } },
      { status: 502 },
    );
  }

  // Upscale-before-crop drops the final stretch from 10× to 2.5×.
  const upscaled = await claid4xUpscale(composed).catch(() => lanczos4x(composed));
  const cropped = await subjectAwareSmartCrop(upscaled, { width: 15_420, height: 1_320 });
  t.mark("postprocess");

  return Response.json({
    image: await uploadToBlob(cropped),
    diagnostics: {
      pipeline,
      editsOk,
      sceneOk,
      moderationBlocked,
      candidateScores: editsCandidate ? [editsCandidate.score] : [],
      subjectFitsInCrop,
      subjectVisiblePct: editsCandidate?.subjectVisiblePct ?? 0,
      timings: t.snapshot(),
    } satisfies Diagnostics,
  });
}

// lib/imageUtils.ts
import sharp from "sharp";

const PROXY_WIDTH = 512;
const SURVIVING_BAND_PCT = 0.12; // final crop preserves the central 12% strip
const HEADROOM_PCT = 0.12;       // top-bias fallback keeps heads in frame

export type ScoredCandidate = {
  image: Buffer;
  score: number;              // higher = more usable detail in the survival band
  subjectFitsInCrop: boolean;
  subjectVisiblePct: number;
  subjectCenterY: number;     // 0..1, used by smartCrop downstream
};

export async function scoreCandidate(image: Buffer): Promise<ScoredCandidate> {
  // Greyscale proxy at 512px wide — fast variance pass, no full-res cost.
  const proxy = await sharp(image)
    .resize(PROXY_WIDTH, null, { fit: "inside" })
    .greyscale()
    .raw()
    .toBuffer({ resolveWithObject: true });

  const { data, info } = proxy;
  const { width: w, height: h } = info;

  // Per-row variance: σ² = ∑x²/n − x̄²
  const rowVariance = new Float32Array(h);
  for (let y = 0; y < h; y++) {
    let sum = 0;
    let sumSq = 0;
    const rowStart = y * w;
    for (let x = 0; x < w; x++) {
      const v = data[rowStart + x];
      sum += v;
      sumSq += v * v;
    }
    const mean = sum / w;
    rowVariance[y] = sumSq / w - mean * mean;
  }

  // Subject band detection: rows > 1.5× median variance.
  const median = quickMedian(rowVariance);
  const threshold = median * 1.5;
  let subjectTop = -1;
  let subjectBottom = -1;
  for (let y = 0; y < h; y++) {
    if (rowVariance[y] > threshold) {
      if (subjectTop === -1) subjectTop = y;
      subjectBottom = y;
    }
  }
  const subjectHeight = Math.max(0, subjectBottom - subjectTop);

  // Variance-weighted center — biases toward faces/hands, not geometric midpoint.
  let weightedSum = 0;
  let weightTotal = 0;
  for (let y = subjectTop; y <= subjectBottom; y++) {
    weightedSum += y * rowVariance[y];
    weightTotal += rowVariance[y];
  }
  const subjectCenterY = weightTotal > 0 ? weightedSum / weightTotal / h : 0.5;

  // Score: variance INSIDE the surviving 12% band only. A candidate with great
  // detail in the top 30% of the frame loses to one with less detail in the
  // central strip — that's the only band that ships.
  const bandStart = Math.floor(h * (subjectCenterY - SURVIVING_BAND_PCT / 2));
  const bandEnd = Math.ceil(h * (subjectCenterY + SURVIVING_BAND_PCT / 2));
  let score = 0;
  for (let y = Math.max(0, bandStart); y < Math.min(h, bandEnd); y++) {
    score += rowVariance[y];
  }

  const subjectFitsInCrop = subjectHeight <= h * SURVIVING_BAND_PCT;
  const subjectVisiblePct = Math.min(1, (h * SURVIVING_BAND_PCT) / Math.max(subjectHeight, 1));

  return { image, score, subjectFitsInCrop, subjectVisiblePct, subjectCenterY };
}

export async function subjectAwareSmartCrop(
  image: Buffer,
  target: { width: number; height: number },
): Promise<Buffer> {
  const meta = await sharp(image).metadata();
  const srcW = meta.width!;
  const srcH = meta.height!;

  // Re-score against the upscaled image to get an accurate subjectCenterY.
  const { subjectCenterY, subjectFitsInCrop } = await scoreCandidate(image);

  const cropH = target.height;
  let topY = Math.round(subjectCenterY * srcH - cropH / 2);

  if (!subjectFitsInCrop) {
    // Subject taller than crop window — top-bias with 12% headroom so the
    // head stays in frame even if feet get cut.
    topY = Math.round(subjectCenterY * srcH - cropH * (1 - HEADROOM_PCT));
  }

  topY = clamp(topY, 0, srcH - cropH);

  return sharp(image)
    .extract({ left: 0, top: topY, width: srcW, height: cropH })
    .resize(target.width, target.height, { fit: "fill" })
    .png()
    .toBuffer();
}

// lib/textComposite.ts
import sharp from "sharp";
import opentype, { type Font } from "opentype.js";
import fs from "node:fs/promises";
import path from "node:path";

const FONT_CACHE = new Map<string, Font>();

async function loadFont(family: string): Promise<Font> {
  const cached = FONT_CACHE.get(family);
  if (cached) return cached;
  const buf = await fs.readFile(
    path.join(process.cwd(), "public/fonts", `${family}.otf`),
  );
  const font = opentype.parse(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength));
  FONT_CACHE.set(family, font);
  return font;
}

export type TextOverlay = {
  text: string;
  fontFamily: string;
  fontSizePx: number;
  color: string;        // e.g. "#fff"
  shadow?: { blur: number; offsetY: number; color: string };
  cx: number;           // 0..1 — horizontal center
  cy: number;           // 0..1 — vertical center
};

/**
 * Compose customer text onto a base image without trusting the platform's
 * SVG font renderer. opentype.js does the layout; sharp does the composite.
 */
export async function burnInText(
  base: Buffer,
  overlay: TextOverlay,
): Promise<Buffer> {
  const meta = await sharp(base).metadata();
  const w = meta.width!;
  const h = meta.height!;

  const font = await loadFont(overlay.fontFamily);

  // opentype.js measures the path itself — bypasses librsvg's text shaping.
  const path = font.getPath(overlay.text, 0, 0, overlay.fontSizePx);
  const bbox = path.getBoundingBox();
  const textW = bbox.x2 - bbox.x1;
  const textH = bbox.y2 - bbox.y1;

  const x = Math.round(overlay.cx * w - textW / 2 - bbox.x1);
  const y = Math.round(overlay.cy * h - textH / 2 - bbox.y1);
  path.commands = path.commands.map((c) => ({
    ...c,
    x: c.x !== undefined ? c.x + x : c.x,
    y: c.y !== undefined ? c.y + y : c.y,
  }));

  const shadow = overlay.shadow
    ? `<filter id="s">
         <feGaussianBlur stdDeviation="${overlay.shadow.blur}" />
       </filter>
       <path d="${path.toPathData(2)}"
             fill="${overlay.shadow.color}"
             transform="translate(0,${overlay.shadow.offsetY})"
             filter="url(#s)" />`
    : "";

  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}">
      ${shadow}
      <path d="${path.toPathData(2)}" fill="${overlay.color}" />
    </svg>`;

  return sharp(base)
    .composite([{ input: Buffer.from(svg), top: 0, left: 0 }])
    .png()
    .toBuffer();
}