ima2-gen 1.1.7 → 1.1.9

package/lib/referenceImageCompress.js

@@ -1,75 +1,64 @@
 import sharp from "sharp";
-
 const DEFAULT_MAX_B64_BYTES = 6 * 1024 * 1024;
 const DEFAULT_MAX_EDGE = 3840;
 const DEFAULT_QUALITY_LADDER = [85, 75, 65, 55];
 const FALLBACK_MAX_EDGE = 2048;
 const FALLBACK_QUALITY_LADDER = [75, 65, 55];
-
 function stripDataUrlPrefix(value) {
-  return String(value || "").replace(/^data:[^;]+;base64,/, "");
+    return String(value || "").replace(/^data:[^;]+;base64,/, "");
 }
-
 function toBase64(buffer) {
-  return buffer.toString("base64");
+    return buffer.toString("base64");
 }
-
-async function encodeJpegWithinBudget(input, {
-  maxB64Bytes,
-  maxEdge,
-  qualityLadder,
-}) {
-  for (const quality of qualityLadder) {
-    const out = await sharp(input, { failOn: "none" })
-      .rotate()
-      .resize({
-        width: maxEdge,
-        height: maxEdge,
-        fit: "inside",
-        withoutEnlargement: true,
-      })
-      .flatten({ background: "#ffffff" })
-      .jpeg({ quality, progressive: true })
-      .toBuffer();
-    const b64 = toBase64(out);
-    if (b64.length <= maxB64Bytes) return { b64, compressed: true, quality, maxEdge };
-  }
-  return null;
+async function encodeJpegWithinBudget(input, { maxB64Bytes, maxEdge, qualityLadder, }) {
+    for (const quality of qualityLadder) {
+        const out = await sharp(input, { failOn: "none" })
+            .rotate()
+            .resize({
+            width: maxEdge,
+            height: maxEdge,
+            fit: "inside",
+            withoutEnlargement: true,
+        })
+            .flatten({ background: "#ffffff" })
+            .jpeg({ quality, progressive: true })
+            .toBuffer();
+        const b64 = toBase64(out);
+        if (b64.length <= maxB64Bytes)
+            return { b64, compressed: true, quality, maxEdge };
+    }
+    return null;
 }
-
 export async function compressReferenceB64ForOAuth(imageB64, options = {}) {
-  const rawB64 = stripDataUrlPrefix(imageB64);
-  const maxB64Bytes = options.maxB64Bytes ?? DEFAULT_MAX_B64_BYTES;
-  const maxEdge = options.maxEdge ?? DEFAULT_MAX_EDGE;
-  const qualityLadder = options.qualityLadder ?? DEFAULT_QUALITY_LADDER;
-  if (!rawB64) return { b64: rawB64, compressed: false, inputBytes: 0, outputBytes: 0 };
-
-  const input = Buffer.from(rawB64, "base64");
-  const inputBytes = rawB64.length;
-  if (!options.force && inputBytes <= maxB64Bytes) {
-    return { b64: rawB64, compressed: false, inputBytes, outputBytes: inputBytes };
-  }
-
-  const primary = await encodeJpegWithinBudget(input, {
-    maxB64Bytes,
-    maxEdge,
-    qualityLadder,
-  });
-  if (primary) {
-    return { ...primary, inputBytes, outputBytes: primary.b64.length };
-  }
-
-  const fallback = await encodeJpegWithinBudget(input, {
-    maxB64Bytes,
-    maxEdge: options.fallbackMaxEdge ?? FALLBACK_MAX_EDGE,
-    qualityLadder: options.fallbackQualityLadder ?? FALLBACK_QUALITY_LADDER,
-  });
-  if (fallback) {
-    return { ...fallback, inputBytes, outputBytes: fallback.b64.length };
-  }
-
-  const err = new Error(`Reference image remains above ${maxB64Bytes} base64 bytes after compression`);
-  err.code = "REF_TOO_LARGE";
-  err.status = 400;
-  throw err;
+    const rawB64 = stripDataUrlPrefix(imageB64);
+    const maxB64Bytes = options.maxB64Bytes ?? DEFAULT_MAX_B64_BYTES;
+    const maxEdge = options.maxEdge ?? DEFAULT_MAX_EDGE;
+    const qualityLadder = options.qualityLadder ?? DEFAULT_QUALITY_LADDER;
+    if (!rawB64)
+        return { b64: rawB64, compressed: false, inputBytes: 0, outputBytes: 0 };
+    const input = Buffer.from(rawB64, "base64");
+    const inputBytes = rawB64.length;
+    if (!options.force && inputBytes <= maxB64Bytes) {
+        return { b64: rawB64, compressed: false, inputBytes, outputBytes: inputBytes };
+    }
+    const primary = await encodeJpegWithinBudget(input, {
+        maxB64Bytes,
+        maxEdge,
+        qualityLadder,
+    });
+    if (primary) {
+        return { ...primary, inputBytes, outputBytes: primary.b64.length };
+    }
+    const fallback = await encodeJpegWithinBudget(input, {
+        maxB64Bytes,
+        maxEdge: options.fallbackMaxEdge ?? FALLBACK_MAX_EDGE,
+        qualityLadder: options.fallbackQualityLadder ?? FALLBACK_QUALITY_LADDER,
+    });
+    if (fallback) {
+        return { ...fallback, inputBytes, outputBytes: fallback.b64.length };
+    }
+    const err = new Error(`Reference image remains above ${maxB64Bytes} base64 bytes after compression`);
+    err.code = "REF_TOO_LARGE";
+    err.status = 400;
+    throw err;
 }

package/lib/referenceImageCompress.ts

@@ -0,0 +1,75 @@
+import sharp from "sharp";
+
+const DEFAULT_MAX_B64_BYTES = 6 * 1024 * 1024;
+const DEFAULT_MAX_EDGE = 3840;
+const DEFAULT_QUALITY_LADDER = [85, 75, 65, 55];
+const FALLBACK_MAX_EDGE = 2048;
+const FALLBACK_QUALITY_LADDER = [75, 65, 55];
+
+function stripDataUrlPrefix(value) {
+  return String(value || "").replace(/^data:[^;]+;base64,/, "");
+}
+
+function toBase64(buffer) {
+  return buffer.toString("base64");
+}
+
+async function encodeJpegWithinBudget(input, {
+  maxB64Bytes,
+  maxEdge,
+  qualityLadder,
+}) {
+  for (const quality of qualityLadder) {
+    const out = await sharp(input, { failOn: "none" })
+      .rotate()
+      .resize({
+        width: maxEdge,
+        height: maxEdge,
+        fit: "inside",
+        withoutEnlargement: true,
+      })
+      .flatten({ background: "#ffffff" })
+      .jpeg({ quality, progressive: true })
+      .toBuffer();
+    const b64 = toBase64(out);
+    if (b64.length <= maxB64Bytes) return { b64, compressed: true, quality, maxEdge };
+  }
+  return null;
+}
+
+export async function compressReferenceB64ForOAuth(imageB64, options: any = {}) {
+  const rawB64 = stripDataUrlPrefix(imageB64);
+  const maxB64Bytes = options.maxB64Bytes ?? DEFAULT_MAX_B64_BYTES;
+  const maxEdge = options.maxEdge ?? DEFAULT_MAX_EDGE;
+  const qualityLadder = options.qualityLadder ?? DEFAULT_QUALITY_LADDER;
+  if (!rawB64) return { b64: rawB64, compressed: false, inputBytes: 0, outputBytes: 0 };
+
+  const input = Buffer.from(rawB64, "base64");
+  const inputBytes = rawB64.length;
+  if (!options.force && inputBytes <= maxB64Bytes) {
+    return { b64: rawB64, compressed: false, inputBytes, outputBytes: inputBytes };
+  }
+
+  const primary = await encodeJpegWithinBudget(input, {
+    maxB64Bytes,
+    maxEdge,
+    qualityLadder,
+  });
+  if (primary) {
+    return { ...primary, inputBytes, outputBytes: primary.b64.length };
+  }
+
+  const fallback = await encodeJpegWithinBudget(input, {
+    maxB64Bytes,
+    maxEdge: options.fallbackMaxEdge ?? FALLBACK_MAX_EDGE,
+    qualityLadder: options.fallbackQualityLadder ?? FALLBACK_QUALITY_LADDER,
+  });
+  if (fallback) {
+    return { ...fallback, inputBytes, outputBytes: fallback.b64.length };
+  }
+
+  const err: any = new Error(`Reference image remains above ${maxB64Bytes} base64 bytes after compression`);
+  err.code = "REF_TOO_LARGE";
+  err.status = 400;
+  throw err;
+}

package/lib/refs.js

@@ -1,98 +1,110 @@
 // lib/refs.js — reference-image validator (0.09.7).
 // Extracted from server.js so unit tests can import without booting the app.
-
 import { config } from "../config.js";
-
 const BASE64_RE = /^[A-Za-z0-9+/]+=*$/;
 const DATA_URL_RE = /^data:([^;,]+);base64,/i;
-
 function approxBase64Bytes(b64) {
-  try {
-    return Buffer.from(b64, "base64").length;
-  } catch {
-    return Math.floor((b64.length * 3) / 4);
-  }
+    try {
+        return Buffer.from(b64, "base64").length;
+    }
+    catch {
+        return Math.floor((b64.length * 3) / 4);
+    }
 }
-
 export function detectImageMimeFromB64(b64) {
-  let buf;
-  try {
-    buf = Buffer.from(b64, "base64");
-  } catch {
+    let buf;
+    try {
+        buf = Buffer.from(b64, "base64");
+    }
+    catch {
+        return null;
+    }
+    if (buf.length >= 4 && buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) {
+        return "image/png";
+    }
+    if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
+        return "image/jpeg";
+    }
+    if (buf.length >= 12 &&
+        buf.toString("ascii", 0, 4) === "RIFF" &&
+        buf.toString("ascii", 8, 12) === "WEBP") {
+        return "image/webp";
+    }
     return null;
-  }
-  if (buf.length >= 4 && buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) {
-    return "image/png";
-  }
-  if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
-    return "image/jpeg";
-  }
-  if (
-    buf.length >= 12 &&
-    buf.toString("ascii", 0, 4) === "RIFF" &&
-    buf.toString("ascii", 8, 12) === "WEBP"
-  ) {
-    return "image/webp";
-  }
-  return null;
 }
-
 export function safeReferenceDiagnostics(refDetails = []) {
-  if (!Array.isArray(refDetails)) return [];
-  return refDetails.map((ref) => ({
-    index: ref.index,
-    declaredMime: ref.declaredMime || null,
-    detectedMime: ref.detectedMime || null,
-    b64Chars: ref.b64Chars,
-    approxBytes: ref.approxBytes,
-    source: ref.source,
-    warnings: ref.warnings || [],
-  }));
+    if (!Array.isArray(refDetails))
+        return [];
+    return refDetails.map((ref) => ({
+        index: ref.index,
+        declaredMime: ref.declaredMime || null,
+        detectedMime: ref.detectedMime || null,
+        b64Chars: ref.b64Chars,
+        approxBytes: ref.approxBytes,
+        source: ref.source,
+        warnings: ref.warnings || [],
+    }));
 }
-
-export function validateAndNormalizeRefs(references, {
-  maxCount = config.limits.maxRefCount,
-  maxB64Bytes = config.limits.maxRefB64Bytes,
-} = {}) {
-  if (!Array.isArray(references)) {
-    return { error: "references must be an array", code: "REF_NOT_ARRAY" };
-  }
-  if (references.length > maxCount) {
-    return { error: `references may not exceed ${maxCount} items`, code: "REF_TOO_MANY" };
-  }
-  const out = [];
-  const refDetails = [];
-  for (let i = 0; i < references.length; i++) {
-    const r = references[i];
-    if (typeof r !== "string") {
-      return { error: `references[${i}] must be a string`, code: "REF_NOT_STRING" };
+export function summarizeReferencePayload(references) {
+    if (!Array.isArray(references)) {
+        return { refsCount: 0, referenceBytes: 0, referenceB64Chars: 0 };
     }
-    const dataUrlMatch = r.match(DATA_URL_RE);
-    const declaredMime = dataUrlMatch?.[1]?.toLowerCase() || null;
-    const b64 = r.replace(DATA_URL_RE, "");
-    if (!b64) return { error: `references[${i}] is empty`, code: "REF_EMPTY" };
-    if (b64.length > maxB64Bytes) {
-      return { error: `references[${i}] exceeds ${maxB64Bytes} bytes`, code: "REF_TOO_LARGE" };
+    let referenceBytes = 0;
+    let referenceB64Chars = 0;
+    for (const ref of references) {
+        if (typeof ref !== "string")
+            continue;
+        const b64 = ref.replace(DATA_URL_RE, "");
+        referenceB64Chars += b64.length;
+        referenceBytes += approxBase64Bytes(b64);
+    }
+    return {
+        refsCount: references.length,
+        referenceBytes,
+        referenceB64Chars,
+    };
+}
+export function validateAndNormalizeRefs(references, { maxCount = config.limits.maxRefCount, maxB64Bytes = config.limits.maxRefB64Bytes, } = {}) {
+    if (!Array.isArray(references)) {
+        return { error: "references must be an array", code: "REF_NOT_ARRAY" };
     }
-    if (!BASE64_RE.test(b64)) {
-      return { error: `references[${i}] is not valid base64`, code: "REF_NOT_BASE64" };
+    if (references.length > maxCount) {
+        return { error: `references may not exceed ${maxCount} items`, code: "REF_TOO_MANY" };
     }
-    const detectedMime = detectImageMimeFromB64(b64);
-    const warnings = [];
-    if (declaredMime && detectedMime && declaredMime !== detectedMime) {
-      warnings.push("mime_mismatch");
+    const out = [];
+    const refDetails = [];
+    for (let i = 0; i < references.length; i++) {
+        const r = references[i];
+        if (typeof r !== "string") {
+            return { error: `references[${i}] must be a string`, code: "REF_NOT_STRING" };
+        }
+        const dataUrlMatch = r.match(DATA_URL_RE);
+        const declaredMime = dataUrlMatch?.[1]?.toLowerCase() || null;
+        const b64 = r.replace(DATA_URL_RE, "");
+        if (!b64)
+            return { error: `references[${i}] is empty`, code: "REF_EMPTY" };
+        if (b64.length > maxB64Bytes) {
+            return { error: `references[${i}] exceeds ${maxB64Bytes} bytes`, code: "REF_TOO_LARGE" };
+        }
+        if (!BASE64_RE.test(b64)) {
+            return { error: `references[${i}] is not valid base64`, code: "REF_NOT_BASE64" };
+        }
+        const detectedMime = detectImageMimeFromB64(b64);
+        const warnings = [];
+        if (declaredMime && detectedMime && declaredMime !== detectedMime) {
+            warnings.push("mime_mismatch");
+        }
+        out.push(b64);
+        refDetails.push({
+            index: i,
+            b64,
+            declaredMime,
+            detectedMime,
+            b64Chars: b64.length,
+            approxBytes: approxBase64Bytes(b64),
+            source: declaredMime ? "dataUrl" : "rawBase64",
+            warnings,
+        });
     }
-    out.push(b64);
-    refDetails.push({
-      index: i,
-      b64,
-      declaredMime,
-      detectedMime,
-      b64Chars: b64.length,
-      approxBytes: approxBase64Bytes(b64),
-      source: declaredMime ? "dataUrl" : "rawBase64",
-      warnings,
-    });
-  }
-  return { refs: out, refDetails, referenceDiagnostics: safeReferenceDiagnostics(refDetails) };
+    return { refs: out, refDetails, referenceDiagnostics: safeReferenceDiagnostics(refDetails) };
 }

package/lib/refs.ts

@@ -0,0 +1,117 @@
+// lib/refs.js — reference-image validator (0.09.7).
+// Extracted from server.js so unit tests can import without booting the app.
+
+import { config } from "../config.js";
+
+const BASE64_RE = /^[A-Za-z0-9+/]+=*$/;
+const DATA_URL_RE = /^data:([^;,]+);base64,/i;
+
+function approxBase64Bytes(b64) {
+  try {
+    return Buffer.from(b64, "base64").length;
+  } catch {
+    return Math.floor((b64.length * 3) / 4);
+  }
+}
+
+export function detectImageMimeFromB64(b64) {
+  let buf;
+  try {
+    buf = Buffer.from(b64, "base64");
+  } catch {
+    return null;
+  }
+  if (buf.length >= 4 && buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) {
+    return "image/png";
+  }
+  if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
+    return "image/jpeg";
+  }
+  if (
+    buf.length >= 12 &&
+    buf.toString("ascii", 0, 4) === "RIFF" &&
+    buf.toString("ascii", 8, 12) === "WEBP"
+  ) {
+    return "image/webp";
+  }
+  return null;
+}
+
+export function safeReferenceDiagnostics(refDetails = []) {
+  if (!Array.isArray(refDetails)) return [];
+  return refDetails.map((ref) => ({
+    index: ref.index,
+    declaredMime: ref.declaredMime || null,
+    detectedMime: ref.detectedMime || null,
+    b64Chars: ref.b64Chars,
+    approxBytes: ref.approxBytes,
+    source: ref.source,
+    warnings: ref.warnings || [],
+  }));
+}
+
+export function summarizeReferencePayload(references) {
+  if (!Array.isArray(references)) {
+    return { refsCount: 0, referenceBytes: 0, referenceB64Chars: 0 };
+  }
+  let referenceBytes = 0;
+  let referenceB64Chars = 0;
+  for (const ref of references) {
+    if (typeof ref !== "string") continue;
+    const b64 = ref.replace(DATA_URL_RE, "");
+    referenceB64Chars += b64.length;
+    referenceBytes += approxBase64Bytes(b64);
+  }
+  return {
+    refsCount: references.length,
+    referenceBytes,
+    referenceB64Chars,
+  };
+}
+
+export function validateAndNormalizeRefs(references, {
+  maxCount = config.limits.maxRefCount,
+  maxB64Bytes = config.limits.maxRefB64Bytes,
+} = {}) {
+  if (!Array.isArray(references)) {
+    return { error: "references must be an array", code: "REF_NOT_ARRAY" };
+  }
+  if (references.length > maxCount) {
+    return { error: `references may not exceed ${maxCount} items`, code: "REF_TOO_MANY" };
+  }
+  const out = [];
+  const refDetails = [];
+  for (let i = 0; i < references.length; i++) {
+    const r = references[i];
+    if (typeof r !== "string") {
+      return { error: `references[${i}] must be a string`, code: "REF_NOT_STRING" };
+    }
+    const dataUrlMatch = r.match(DATA_URL_RE);
+    const declaredMime = dataUrlMatch?.[1]?.toLowerCase() || null;
+    const b64 = r.replace(DATA_URL_RE, "");
+    if (!b64) return { error: `references[${i}] is empty`, code: "REF_EMPTY" };
+    if (b64.length > maxB64Bytes) {
+      return { error: `references[${i}] exceeds ${maxB64Bytes} bytes`, code: "REF_TOO_LARGE" };
+    }
+    if (!BASE64_RE.test(b64)) {
+      return { error: `references[${i}] is not valid base64`, code: "REF_NOT_BASE64" };
+    }
+    const detectedMime = detectImageMimeFromB64(b64);
+    const warnings = [];
+    if (declaredMime && detectedMime && declaredMime !== detectedMime) {
+      warnings.push("mime_mismatch");
+    }
+    out.push(b64);
+    refDetails.push({
+      index: i,
+      b64,
+      declaredMime,
+      detectedMime,
+      b64Chars: b64.length,
+      approxBytes: approxBase64Bytes(b64),
+      source: declaredMime ? "dataUrl" : "rawBase64",
+      warnings,
+    });
+  }
+  return { refs: out, refDetails, referenceDiagnostics: safeReferenceDiagnostics(refDetails) };
+}

package/lib/requestLogger.js

@@ -1,48 +1,42 @@
 import { randomUUID } from "crypto";
 import { logEvent } from "./logger.js";
-
 const REQUEST_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
 const IGNORED_LOG_PATHS = new Set(["/api/health", "/api/inflight"]);
-
 export function normalizeRequestId(value) {
-  return typeof value === "string" && REQUEST_ID_RE.test(value) ? value : `req_${randomUUID()}`;
+    return typeof value === "string" && REQUEST_ID_RE.test(value) ? value : `req_${randomUUID()}`;
 }
-
 function requestPath(req) {
-  return String(req.originalUrl || req.url || "").split("?")[0] || "/";
+    return String(req.originalUrl || req.url || "").split("?")[0] || "/";
 }
-
 export function createRequestLogger() {
-  return function requestLogger(req, res, next) {
-    const path = requestPath(req);
-    if (!path.startsWith("/api/")) return next();
-
-    const requestId = normalizeRequestId(req.get("x-request-id"));
-    const startedAt = Date.now();
-    req.id = requestId;
-    res.setHeader("X-Request-Id", requestId);
-
-    const ignoreLog = IGNORED_LOG_PATHS.has(path);
-    if (!ignoreLog) {
-      logEvent("http", "request", {
-        requestId,
-        method: req.method,
-        path,
-        client: req.get("x-ima2-client") || "ui",
-      });
-    }
-
-    res.on("finish", () => {
-      if (ignoreLog) return;
-      logEvent("http", "response", {
-        requestId,
-        method: req.method,
-        path,
-        status: res.statusCode,
-        durationMs: Date.now() - startedAt,
-      });
-    });
-
-    next();
-  };
+    return function requestLogger(req, res, next) {
+        const path = requestPath(req);
+        if (!path.startsWith("/api/"))
+            return next();
+        const requestId = normalizeRequestId(req.get("x-request-id"));
+        const startedAt = Date.now();
+        req.id = requestId;
+        res.setHeader("X-Request-Id", requestId);
+        const ignoreLog = IGNORED_LOG_PATHS.has(path);
+        if (!ignoreLog) {
+            logEvent("http", "request", {
+                requestId,
+                method: req.method,
+                path,
+                client: req.get("x-ima2-client") || "ui",
+            });
+        }
+        res.on("finish", () => {
+            if (ignoreLog)
+                return;
+            logEvent("http", "response", {
+                requestId,
+                method: req.method,
+                path,
+                status: res.statusCode,
+                durationMs: Date.now() - startedAt,
+            });
+        });
+        next();
+    };
 }

package/lib/requestLogger.ts

@@ -0,0 +1,48 @@
+import { randomUUID } from "crypto";
+import { logEvent } from "./logger.js";
+
+const REQUEST_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+const IGNORED_LOG_PATHS = new Set(["/api/health", "/api/inflight"]);
+
+export function normalizeRequestId(value) {
+  return typeof value === "string" && REQUEST_ID_RE.test(value) ? value : `req_${randomUUID()}`;
+}
+
+function requestPath(req) {
+  return String(req.originalUrl || req.url || "").split("?")[0] || "/";
+}
+
+export function createRequestLogger() {
+  return function requestLogger(req, res, next) {
+    const path = requestPath(req);
+    if (!path.startsWith("/api/")) return next();
+
+    const requestId = normalizeRequestId(req.get("x-request-id"));
+    const startedAt = Date.now();
+    req.id = requestId;
+    res.setHeader("X-Request-Id", requestId);
+
+    const ignoreLog = IGNORED_LOG_PATHS.has(path);
+    if (!ignoreLog) {
+      logEvent("http", "request", {
+        requestId,
+        method: req.method,
+        path,
+        client: req.get("x-ima2-client") || "ui",
+      });
+    }
+
+    res.on("finish", () => {
+      if (ignoreLog) return;
+      logEvent("http", "response", {
+        requestId,
+        method: req.method,
+        path,
+        status: res.statusCode,
+        durationMs: Date.now() - startedAt,
+      });
+    });
+
+    next();
+  };
+}