@koda-sl/baker-cli 0.290.1 → 0.290.2

package/dist/{chunk-V7BIRLPU.js → chunk-NNQDWCFG.js}

@@ -6022,9 +6022,8 @@ async function ingestImageUrl(url, ctx) {
   } catch (e) {
     throw localExecError(ctx, `${url}: ${e.message}`);
   }
-  if (normalized.rasterizedFrom) {
-    ctx.log(`ingest: normalized ${normalized.rasterizedFrom} URL -> PNG (${normalized.bytes.length}B)`);
-  }
+  const note = normalizationNote(normalized);
+  if (note) ctx.log(`ingest: ${url} ${note}`);
   return uploadAndIngest({
     bytes: normalized.bytes,
     kind: "image",
@@ -6134,23 +6133,69 @@ async function rasterizeSvgToPng(bytes) {
   return await sharp(bytes, { density }).png({ force: true, palette: false }).toBuffer();
 }
 var MODEL_SAFE_IMAGE_MIMES = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
-async function toModelSafeImage(bytes) {
+var MAX_MODEL_REFERENCE_BYTES = 30 * 1024 * 1024;
+async function fitWithinReferenceLimit(bytes, mime, maxBytes) {
+  if (bytes.byteLength <= maxBytes) return { bytes, mime };
+  const { default: sharp } = await import("sharp");
+  const read = () => sharp(bytes, { animated: true });
+  const meta = await read().metadata();
+  const animated = (meta.pages ?? 1) > 1;
+  const keepAlpha = meta.hasAlpha === true;
+  const width = meta.width ?? 0;
+  const encode = async (scale2) => {
+    let pipeline2 = read();
+    if (scale2 < 1 && width > 0) pipeline2 = pipeline2.resize({ width: Math.max(256, Math.round(width * scale2)) });
+    if (animated && mime === "image/gif") return { bytes: await pipeline2.gif().toBuffer(), mime: "image/gif" };
+    if (animated || keepAlpha) return { bytes: await pipeline2.webp({ quality: 90 }).toBuffer(), mime: "image/webp" };
+    return { bytes: await pipeline2.jpeg({ quality: 90, mozjpeg: true }).toBuffer(), mime: "image/jpeg" };
+  };
+  let out = await encode(1);
+  let scale = 1;
+  for (let pass = 0; pass < 4 && out.bytes.byteLength > maxBytes; pass++) {
+    scale *= Math.min(0.9, Math.sqrt(maxBytes / out.bytes.byteLength));
+    out = await encode(scale);
+  }
+  return out;
+}
+async function toModelSafeImage(bytes, opts) {
+  const maxBytes = opts?.maxBytes ?? MAX_MODEL_REFERENCE_BYTES;
+  const fit = async (candidate, mime, rasterizedFrom) => {
+    const fitted = await fitWithinReferenceLimit(candidate, mime, maxBytes);
+    return {
+      bytes: fitted.bytes,
+      mime: fitted.mime,
+      ...rasterizedFrom ? { rasterizedFrom } : {},
+      ...fitted.bytes === candidate ? {} : { shrunkFromBytes: candidate.byteLength }
+    };
+  };
   const safe = sniffImageMime(bytes);
   if (safe && MODEL_SAFE_IMAGE_MIMES.has(safe)) {
-    return { bytes, mime: safe };
+    return await fit(bytes, safe);
   }
   if (sniffSvg(bytes)) {
-    return { bytes: await rasterizeSvgToPng(bytes), mime: "image/png", rasterizedFrom: "svg" };
+    return await fit(await rasterizeSvgToPng(bytes), "image/png", "svg");
   }
   const { default: sharp } = await import("sharp");
+  let png;
+  let format;
   try {
     const img = sharp(bytes);
-    const format = (await img.metadata()).format;
-    const png = await img.png({ force: true }).toBuffer();
-    return { bytes: png, mime: "image/png", rasterizedFrom: format ?? "unknown" };
+    format = (await img.metadata()).format ?? "unknown";
+    png = await img.png({ force: true }).toBuffer();
   } catch (e) {
     throw new Error(`bytes are not a decodable image (${e.message})`);
   }
+  return await fit(png, "image/png", format);
+}
+function normalizationNote(image) {
+  const parts = [];
+  if (image.rasterizedFrom) parts.push(`normalized ${image.rasterizedFrom} -> ${image.mime}`);
+  if (image.shrunkFromBytes !== void 0) {
+    parts.push(
+      `fitted ${image.shrunkFromBytes}B -> ${image.bytes.length}B as ${image.mime} (providers refuse a reference over ${MAX_MODEL_REFERENCE_BYTES}B)`
+    );
+  }
+  return parts.length > 0 ? parts.join("; ") : null;
 }
 function hasAscii(buf, offset, sig) {
   return buf.length >= offset + sig.length && buf.toString("ascii", offset, offset + sig.length) === sig;
@@ -6280,7 +6325,8 @@ async function execLocalFile(params, ctx) {
     outBytes = normalized.bytes;
     outMime = normalized.mime;
     rasterizedFrom = normalized.rasterizedFrom;
-    if (rasterizedFrom) ctx.log(`ingest: normalized ${rasterizedFrom} -> PNG (${outBytes.length}B)`);
+    const note = normalizationNote(normalized);
+    if (note) ctx.log(`ingest: ${note}`);
   }
   const durationMs = probeVideoDurationMs(params.expect, outBytes, ctx);
   const ref = await uploadAndIngest({
@@ -9153,4 +9199,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-V7BIRLPU.js.map
+//# sourceMappingURL=chunk-NNQDWCFG.js.map