@modainteract/moda-interact-shared 5.11.1 → 5.12.0

package/dist/commerce/presentation/node/index.js

@@ -0,0 +1,976 @@
+import {
+  ConversationPreparedProductImageSchema,
+  ConversationProductImageSourceSchema,
+  stableJson
+} from "../../../chunk-SOAGFZ7A.js";
+import "../../../chunk-W5Y5ZLGN.js";
+import "../../../chunk-GCCT2BDE.js";
+import "../../../chunk-4KSODB2R.js";
+import "../../../chunk-AUS3WQIW.js";
+
+// src/commerce/presentation/node/contracts.ts
+var SHOP_BRAND_CANVAS = Object.freeze({ width: 1125, height: 600 });
+var SHOP_BRAND_MAX_SOURCE_BYTES = 10 * 1024 * 1024;
+var SHOP_BRAND_MAX_OUTPUT_BYTES = 5 * 1024 * 1024;
+var SHOP_BRAND_TARGET_OUTPUT_BYTES = 1024 * 1024;
+var SHOP_BRAND_MAX_INPUT_PIXELS = 4e7;
+var ShopBrandMediaError = class extends Error {
+  constructor(code, retryable = false, providerMessage) {
+    super(code);
+    this.code = code;
+    this.retryable = retryable;
+    this.providerMessage = providerMessage;
+    this.name = "ShopBrandMediaError";
+  }
+  code;
+  retryable;
+  providerMessage;
+};
+function boundedMediaProviderMessage(error) {
+  const raw = error instanceof Error ? error.message : typeof error === "string" ? error : void 0;
+  if (!raw) return void 0;
+  const message = [...raw].map((character) => {
+    const code = character.codePointAt(0);
+    return code <= 31 || code === 127 ? " " : character;
+  }).join("").replace(/\bhttps?:\/\/[^\s,;]+/gi, "[URL REDACTED]").replace(/(authorization\s*[:=]\s*)(?:bearer\s+)?[^\s,;]+/gi, "$1[REDACTED]").replace(/\b(bearer\s+)[A-Za-z0-9._~+/-]+=*/gi, "$1[REDACTED]").replace(/((?:access.?key(?:.?id)?|secret.?key|session.?token|security.?token|token|password|signature|credential|api.?key)\s*[:=]\s*)[^\s,;&"'<>]+/gi, "$1[REDACTED]").replace(/[\w.+-]+@[\w.-]+\.[A-Za-z]{2,}/g, "[EMAIL REDACTED]").replace(/\b(?:\+?\d[\d ().-]{7,}\d)\b/g, "[PHONE REDACTED]").replace(/\s+/g, " ").trim().slice(0, 300);
+  return message || void 0;
+}
+
+// src/commerce/presentation/node/network-policy.ts
+import { lookup as dnsLookup } from "dns/promises";
+import { BlockList, isIP } from "net";
+var MERCHANT_KNOWLEDGE_ACQUISITION_ERROR_CODES = [
+  "INVALID_URL",
+  "DENIED_DESTINATION",
+  "DNS_NO_ADDRESSES",
+  "DNS_TEMPORARY_FAILURE",
+  "DNS_FAILURE",
+  "TOO_MANY_REDIRECTS",
+  "INVALID_REDIRECT",
+  "REQUEST_DEADLINE",
+  "CONNECTION_PEER_MISMATCH",
+  "HTTP_STATUS_TRANSIENT",
+  "HTTP_STATUS_PERMANENT",
+  "UNSUPPORTED_MEDIA_TYPE",
+  "UNSUPPORTED_CONTENT_ENCODING",
+  "BODY_TOO_LARGE",
+  "RESPONSE_READ_FAILED"
+];
+var MerchantKnowledgeAcquisitionError = class extends Error {
+  constructor(code, message, retryable = false) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "MerchantKnowledgeAcquisitionError";
+  }
+  code;
+  retryable;
+};
+var GLOBAL_IPV4 = new BlockList();
+GLOBAL_IPV4.addSubnet("0.0.0.0", 0, "ipv4");
+var PUBLIC_IPV6_ALLOCATION_CIDRS = [
+  ["2001:200::", 23],
+  ["2001:400::", 23],
+  ["2001:600::", 23],
+  ["2001:800::", 22],
+  ["2001:c00::", 23],
+  ["2001:e00::", 23],
+  ["2001:1200::", 23],
+  ["2001:1400::", 22],
+  ["2001:1800::", 23],
+  ["2001:1a00::", 23],
+  ["2001:1c00::", 22],
+  ["2001:2000::", 19],
+  ["2001:4000::", 23],
+  ["2001:4200::", 23],
+  ["2001:4400::", 23],
+  ["2001:4600::", 23],
+  ["2001:4800::", 23],
+  ["2001:4a00::", 23],
+  ["2001:4c00::", 23],
+  ["2001:5000::", 20],
+  ["2001:8000::", 19],
+  ["2001:a000::", 20],
+  ["2001:b000::", 20],
+  ["2003::", 18],
+  ["2400::", 12],
+  ["2410::", 12],
+  ["2600::", 12],
+  ["2610::", 23],
+  ["2620::", 23],
+  ["2630::", 12],
+  ["2800::", 12],
+  ["2a00::", 12],
+  ["2a10::", 12],
+  ["2c00::", 12]
+];
+var PUBLIC_IPV6_ALLOCATIONS = new BlockList();
+for (const [network, prefix] of PUBLIC_IPV6_ALLOCATION_CIDRS) {
+  PUBLIC_IPV6_ALLOCATIONS.addSubnet(network, prefix, "ipv6");
+}
+var NON_PUBLIC_SPECIAL_USE_CIDRS = [
+  ["0.0.0.0", 8, "ipv4"],
+  ["10.0.0.0", 8, "ipv4"],
+  ["100.64.0.0", 10, "ipv4"],
+  ["127.0.0.0", 8, "ipv4"],
+  ["169.254.0.0", 16, "ipv4"],
+  ["172.16.0.0", 12, "ipv4"],
+  ["192.0.0.0", 24, "ipv4"],
+  ["192.0.2.0", 24, "ipv4"],
+  ["192.31.196.0", 24, "ipv4"],
+  ["192.52.193.0", 24, "ipv4"],
+  ["192.88.99.0", 24, "ipv4"],
+  ["192.168.0.0", 16, "ipv4"],
+  ["192.175.48.0", 24, "ipv4"],
+  ["198.18.0.0", 15, "ipv4"],
+  ["198.51.100.0", 24, "ipv4"],
+  ["203.0.113.0", 24, "ipv4"],
+  ["224.0.0.0", 4, "ipv4"],
+  ["240.0.0.0", 4, "ipv4"],
+  ["64:ff9b::", 96, "ipv6"],
+  ["64:ff9b:1::", 48, "ipv6"],
+  ["100::", 64, "ipv6"],
+  ["2001::", 23, "ipv6"],
+  ["2001:db8::", 32, "ipv6"],
+  ["2002::", 16, "ipv6"],
+  ["2620:4f:8000::", 48, "ipv6"],
+  ["3fff::", 20, "ipv6"],
+  ["5f00::", 16, "ipv6"]
+];
+var NON_PUBLIC_SPECIAL_USE = new BlockList();
+for (const [network, prefix, family] of NON_PUBLIC_SPECIAL_USE_CIDRS) {
+  NON_PUBLIC_SPECIAL_USE.addSubnet(network, prefix, family);
+}
+var IPV4_MAPPED_IPV6 = new BlockList();
+IPV4_MAPPED_IPV6.addSubnet("::ffff:0:0", 96, "ipv6");
+var TEMPORARY_DNS_CODES = /* @__PURE__ */ new Set(["EAI_AGAIN", "ETIMEOUT", "ETIMEDOUT"]);
+function errorCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return void 0;
+  }
+  return typeof error.code === "string" ? error.code : void 0;
+}
+function hostnameWithoutBrackets(hostname) {
+  return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+}
+function normalizeIpAddress(address) {
+  const family = isIP(address);
+  if (family === 4) return address;
+  if (family !== 6) return null;
+  try {
+    const canonical = new URL(`http://[${address}]/`).hostname.slice(1, -1);
+    if (!IPV4_MAPPED_IPV6.check(canonical, "ipv6")) return canonical;
+    const groups = canonical.split(":");
+    const first = Number.parseInt(groups.at(-2), 16);
+    const second = Number.parseInt(groups.at(-1), 16);
+    return [first >> 8, first & 255, second >> 8, second & 255].join(".");
+  } catch {
+    return null;
+  }
+}
+function isPublicIpAddress(address) {
+  if (address.includes("%")) return false;
+  const family = isIP(address);
+  if (family === 0) return false;
+  if (family === 6 && IPV4_MAPPED_IPV6.check(address, "ipv6")) {
+    const normalized = normalizeIpAddress(address);
+    return normalized !== null && isPublicIpAddress(normalized);
+  }
+  const allowed = family === 4 ? GLOBAL_IPV4.check(address, "ipv4") : PUBLIC_IPV6_ALLOCATIONS.check(address, "ipv6");
+  return allowed && !NON_PUBLIC_SPECIAL_USE.check(address, family === 4 ? "ipv4" : "ipv6");
+}
+async function resolveAllDnsAnswers(hostname) {
+  const addresses = await dnsLookup(hostname, { all: true, verbatim: true });
+  return addresses.map(({ address, family }) => ({
+    address,
+    family: family === 4 ? 4 : 6
+  }));
+}
+async function resolveAndValidateDestination(hostnameInput, resolver = resolveAllDnsAnswers) {
+  const hostname = hostnameWithoutBrackets(hostnameInput);
+  const literalFamily = isIP(hostname);
+  if (literalFamily !== 0) {
+    if (!isPublicIpAddress(hostname)) {
+      throw new MerchantKnowledgeAcquisitionError(
+        "DENIED_DESTINATION",
+        "The requested destination is not globally routable."
+      );
+    }
+    return {
+      address: normalizeIpAddress(hostname) ?? hostname,
+      family: literalFamily
+    };
+  }
+  let answers;
+  try {
+    answers = await resolver(hostname);
+  } catch (error) {
+    const code = errorCode(error);
+    if (code && TEMPORARY_DNS_CODES.has(code)) {
+      throw new MerchantKnowledgeAcquisitionError(
+        "DNS_TEMPORARY_FAILURE",
+        "Temporary DNS resolution failure.",
+        true
+      );
+    }
+    throw new MerchantKnowledgeAcquisitionError(
+      "DNS_FAILURE",
+      "DNS resolution failed."
+    );
+  }
+  if (answers.length === 0) {
+    throw new MerchantKnowledgeAcquisitionError(
+      "DNS_NO_ADDRESSES",
+      "The destination has no DNS addresses."
+    );
+  }
+  const validated = answers.map(({ address, family }) => {
+    const actualFamily = isIP(address);
+    if (family !== 4 && family !== 6 || actualFamily !== family || !isPublicIpAddress(address)) {
+      throw new MerchantKnowledgeAcquisitionError(
+        "DENIED_DESTINATION",
+        "The requested destination is not globally routable."
+      );
+    }
+    return {
+      address,
+      family
+    };
+  });
+  validated.sort(
+    (left, right) => left.family - right.family || (left.address < right.address ? -1 : left.address > right.address ? 1 : 0)
+  );
+  return validated[0];
+}
+function addressesMatch(left, right) {
+  const normalizedLeft = normalizeIpAddress(left);
+  const normalizedRight = normalizeIpAddress(right);
+  return normalizedLeft !== null && normalizedLeft === normalizedRight;
+}
+function createPinnedLookup(address) {
+  return (_hostname, options, callback) => {
+    if (options.all) {
+      callback(null, [{ address: address.address, family: address.family }]);
+      return;
+    }
+    callback(null, address.address, address.family);
+  };
+}
+
+// src/commerce/presentation/node/safe-fetch.ts
+import https from "https";
+import { isIP as isIP2 } from "net";
+var MAX_URL_LENGTH = 2048;
+var MAX_REDIRECTS = 3;
+var DEADLINE_MS = 1e4;
+var REDIRECTS = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var TRANSIENT_HTTP = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+var TRANSIENT_NETWORK = /* @__PURE__ */ new Set(["ECONNRESET", "EAI_AGAIN", "ETIMEDOUT", "ETIMEOUT", "ECONNREFUSED", "ENETUNREACH"]);
+var REQUEST_HEADERS = Object.freeze({
+  Accept: "image/avif,image/webp,image/png,image/jpeg,image/gif,image/svg+xml,*/*;q=0.2",
+  "Accept-Encoding": "identity",
+  "User-Agent": "ModaInteract-ShopBrandMedia/1.0"
+});
+function safeUrl(input) {
+  if (typeof input !== "string" || input.length > MAX_URL_LENGTH || /[\s\p{Cc}]/u.test(input)) {
+    throw new ShopBrandMediaError("UNSAFE_SOURCE");
+  }
+  try {
+    const url = new URL(input);
+    if (url.protocol !== "https:" || url.username || url.password || url.hash || url.port && url.port !== "443" || !url.hostname) {
+      throw new Error("unapproved-url");
+    }
+    return url;
+  } catch {
+    throw new ShopBrandMediaError("UNSAFE_SOURCE");
+  }
+}
+function header(headers, name) {
+  const value = headers[name];
+  return typeof value === "string" ? value : void 0;
+}
+function networkCode(error) {
+  return error !== null && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function sanitiseNetworkError(error) {
+  if (error instanceof ShopBrandMediaError) return error;
+  if (error instanceof MerchantKnowledgeAcquisitionError) {
+    if (error.code === "DENIED_DESTINATION") return new ShopBrandMediaError("UNSAFE_SOURCE", false, error.code);
+    if (error.code === "DNS_TEMPORARY_FAILURE") return new ShopBrandMediaError("DNS_TEMPORARY_FAILURE", true, error.code);
+    return new ShopBrandMediaError("DNS_FAILURE", error.retryable, error.code);
+  }
+  const code = networkCode(error);
+  return new ShopBrandMediaError(
+    "SOURCE_UNAVAILABLE",
+    TRANSIENT_NETWORK.has(code ?? ""),
+    boundedMediaProviderMessage(error)
+  );
+}
+function cancelled(signal) {
+  return signal.reason instanceof ShopBrandMediaError ? signal.reason : new ShopBrandMediaError("SOURCE_TIMEOUT", true);
+}
+function deadline(promise, signal) {
+  if (signal.aborted) return Promise.reject(cancelled(signal));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(cancelled(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+function pinnedHttpsRequest(input, signal) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+    const request = https.request({
+      hostname: input.hostname,
+      port: 443,
+      path: input.path,
+      method: "GET",
+      headers: input.headers,
+      lookup: createPinnedLookup(input.address),
+      agent: false,
+      minVersion: "TLSv1.2",
+      signal,
+      ...input.servername ? { servername: input.servername } : {}
+    }, (response) => {
+      const peerAddress = response.socket.remoteAddress;
+      if (!peerAddress || !addressesMatch(peerAddress, input.address.address)) {
+        response.destroy();
+        fail(new ShopBrandMediaError("UNSAFE_SOURCE"));
+        request.destroy();
+        return;
+      }
+      if (settled) {
+        response.destroy();
+        return;
+      }
+      settled = true;
+      resolve({
+        statusCode: response.statusCode ?? 0,
+        headers: response.headers,
+        body: response,
+        peerAddress
+      });
+    });
+    request.once("socket", (socket) => {
+      socket.once("secureConnect", () => {
+        if (!socket.remoteAddress || !addressesMatch(socket.remoteAddress, input.address.address)) {
+          fail(new ShopBrandMediaError("UNSAFE_SOURCE"));
+          request.destroy();
+        }
+      });
+    });
+    request.once("error", fail);
+    request.end();
+  });
+}
+async function boundedBody(response, signal, maxBytes) {
+  const rawSize = header(response.headers, "content-length");
+  if (rawSize !== void 0 && (!/^\d+$/.test(rawSize) || Number(rawSize) > maxBytes)) {
+    response.body.destroy();
+    throw new ShopBrandMediaError("SOURCE_TOO_LARGE");
+  }
+  const encoding = header(response.headers, "content-encoding");
+  if (encoding !== void 0 && encoding.toLowerCase().trim() !== "identity") {
+    response.body.destroy();
+    throw new ShopBrandMediaError("UNSUPPORTED_ENCODING");
+  }
+  const chunks = [];
+  let length = 0;
+  const onAbort = () => response.body.destroy(cancelled(signal));
+  signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    for await (const chunk of response.body) {
+      if (signal.aborted) throw cancelled(signal);
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      length += bytes.length;
+      if (length > maxBytes) {
+        response.body.destroy();
+        throw new ShopBrandMediaError("SOURCE_TOO_LARGE");
+      }
+      chunks.push(bytes);
+    }
+    if (signal.aborted) throw cancelled(signal);
+    return Buffer.concat(chunks, length);
+  } catch (error) {
+    if (signal.aborted) throw cancelled(signal);
+    if (error instanceof ShopBrandMediaError) throw error;
+    throw sanitiseNetworkError(error);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+function createSafeImageFetcher(options = {}) {
+  const resolveAll = options.resolveAll ?? resolveAllDnsAnswers;
+  const request = options.request ?? pinnedHttpsRequest;
+  const maxRedirects = options.maxRedirects ?? MAX_REDIRECTS;
+  const maxBytes = options.maxBytes ?? SHOP_BRAND_MAX_SOURCE_BYTES;
+  return {
+    async fetch(sourceUrl, externalSignal) {
+      const controller = new AbortController();
+      const abortFromCaller = () => controller.abort(externalSignal?.reason);
+      if (externalSignal?.aborted) abortFromCaller();
+      else externalSignal?.addEventListener("abort", abortFromCaller, { once: true });
+      const timer = setTimeout(() => controller.abort(new ShopBrandMediaError("SOURCE_TIMEOUT", true)), DEADLINE_MS);
+      try {
+        let next = safeUrl(sourceUrl);
+        for (let redirects = 0; ; redirects += 1) {
+          const host = next.hostname.startsWith("[") ? next.hostname.slice(1, -1) : next.hostname;
+          let address;
+          try {
+            address = await deadline(resolveAndValidateDestination(next.hostname, resolveAll), controller.signal);
+          } catch (error) {
+            throw sanitiseNetworkError(error);
+          }
+          const input = {
+            hostname: host,
+            path: `${next.pathname}${next.search}`,
+            address,
+            headers: REQUEST_HEADERS,
+            ...isIP2(host) === 0 ? { servername: host } : {}
+          };
+          let response;
+          try {
+            response = await deadline(request(input, controller.signal), controller.signal);
+          } catch (error) {
+            throw sanitiseNetworkError(error);
+          }
+          if (!addressesMatch(response.peerAddress, address.address)) {
+            response.body.destroy();
+            throw new ShopBrandMediaError("UNSAFE_SOURCE");
+          }
+          if (REDIRECTS.has(response.statusCode)) {
+            response.body.destroy();
+            if (redirects >= maxRedirects) throw new ShopBrandMediaError("UNSAFE_SOURCE");
+            const location = header(response.headers, "location");
+            if (!location) throw new ShopBrandMediaError("UNSAFE_SOURCE");
+            try {
+              next = safeUrl(new URL(location, next).toString());
+            } catch {
+              throw new ShopBrandMediaError("UNSAFE_SOURCE");
+            }
+            continue;
+          }
+          if (response.statusCode !== 200) {
+            response.body.destroy();
+            throw new ShopBrandMediaError(TRANSIENT_HTTP.has(response.statusCode) ? "SOURCE_UNAVAILABLE" : "SOURCE_HTTP_FAILURE", TRANSIENT_HTTP.has(response.statusCode));
+          }
+          const bytes = await boundedBody(response, controller.signal, maxBytes);
+          if (!bytes.length) throw new ShopBrandMediaError("INVALID_IMAGE");
+          const declaredContentType = header(response.headers, "content-type")?.split(";", 1)[0]?.trim().toLowerCase() ?? null;
+          return { bytes, declaredContentType };
+        }
+      } catch (error) {
+        if (controller.signal.aborted) throw cancelled(controller.signal);
+        if (error instanceof ShopBrandMediaError) throw error;
+        throw sanitiseNetworkError(error);
+      } finally {
+        clearTimeout(timer);
+        externalSignal?.removeEventListener("abort", abortFromCaller);
+      }
+    }
+  };
+}
+
+// src/commerce/presentation/node/image-transformer.ts
+import sharp2 from "sharp";
+
+// src/commerce/presentation/node/metadata-verifier.ts
+import { createHash } from "crypto";
+import sharp from "sharp";
+async function verifyEncodedBrandImage(bytes, contentType) {
+  if (!bytes.length || bytes.length >= SHOP_BRAND_MAX_OUTPUT_BYTES || contentType !== "image/jpeg" && contentType !== "image/png") {
+    throw new ShopBrandMediaError("OUTPUT_TOO_LARGE");
+  }
+  try {
+    const actual = await sharp(bytes, {
+      limitInputPixels: SHOP_BRAND_CANVAS.width * SHOP_BRAND_CANVAS.height + 1,
+      failOn: "error",
+      animated: false
+    }).metadata();
+    const format = contentType === "image/jpeg" ? "jpeg" : "png";
+    if (actual.format !== format || actual.width !== SHOP_BRAND_CANVAS.width || actual.height !== SHOP_BRAND_CANVAS.height || (actual.pages ?? 1) !== 1 || actual.exif || actual.xmp || actual.iptc || actual.icc || actual.orientation && actual.orientation !== 1) {
+      throw new ShopBrandMediaError("OUTPUT_VERIFICATION_FAILED");
+    }
+    return {
+      bytes,
+      contentType,
+      width: actual.width,
+      height: actual.height,
+      sizeBytes: bytes.length,
+      contentSha256: createHash("sha256").update(bytes).digest("hex")
+    };
+  } catch {
+    throw new ShopBrandMediaError("OUTPUT_VERIFICATION_FAILED");
+  }
+}
+
+// src/commerce/presentation/node/image-transformer.ts
+var SUPPORTED_SOURCES = /* @__PURE__ */ new Set(["jpeg", "png", "webp", "avif", "heif", "gif", "svg", "tiff"]);
+function assertSelfContainedSvg(bytes) {
+  const markup = bytes.toString("utf8");
+  if (/(?:<!DOCTYPE|<!ENTITY|<\s*(?:script|image|use|foreignObject|iframe|object|embed|style|feImage)\b|(?:xlink:)?href\s*=|url\s*\(|@import\b|\bon[a-z]+\s*=)/i.test(markup)) {
+    throw new ShopBrandMediaError("INVALID_IMAGE");
+  }
+}
+function createShopBrandImageTransformer() {
+  return {
+    async transform(bytes, role) {
+      if (!Buffer.isBuffer(bytes) || !bytes.length || !["LOGO", "SQUARE_LOGO", "COVER_IMAGE"].includes(role)) {
+        throw new ShopBrandMediaError("INVALID_IMAGE");
+      }
+      let mime;
+      let output;
+      try {
+        if (bytes.subarray(0, 512).toString("utf8").replace(/^\uFEFF/, "").trimStart().startsWith("<")) {
+          assertSelfContainedSvg(bytes);
+        }
+        const source = sharp2(bytes, {
+          limitInputPixels: SHOP_BRAND_MAX_INPUT_PIXELS,
+          failOn: "error",
+          animated: false,
+          pages: 1
+        });
+        const info = await source.metadata();
+        if (!info.format || !SUPPORTED_SOURCES.has(info.format) || !info.width || !info.height) {
+          throw new ShopBrandMediaError("INVALID_IMAGE");
+        }
+        if (info.format === "svg") assertSelfContainedSvg(bytes);
+        if (info.width * info.height > SHOP_BRAND_MAX_INPUT_PIXELS) {
+          throw new ShopBrandMediaError("INPUT_PIXELS_EXCEEDED");
+        }
+        const transparent = Boolean(info.hasAlpha);
+        mime = transparent ? "image/png" : "image/jpeg";
+        const build = () => {
+          const image = sharp2(bytes, {
+            limitInputPixels: SHOP_BRAND_MAX_INPUT_PIXELS,
+            failOn: "error",
+            animated: false,
+            pages: 1
+          }).rotate().toColourspace("srgb").resize(SHOP_BRAND_CANVAS.width, SHOP_BRAND_CANVAS.height, {
+            fit: role === "COVER_IMAGE" ? "cover" : "contain",
+            position: "centre",
+            background: transparent ? { r: 255, g: 255, b: 255, alpha: 0 } : { r: 255, g: 255, b: 255, alpha: 1 },
+            withoutEnlargement: false
+          });
+          return transparent ? image : image.flatten({ background: "#ffffff" }).removeAlpha();
+        };
+        if (transparent) {
+          output = await build().png({ compressionLevel: 9, palette: false }).toBuffer();
+          if (output.length > SHOP_BRAND_TARGET_OUTPUT_BYTES) {
+            const compact = await build().png({
+              compressionLevel: 9,
+              palette: true,
+              quality: 100,
+              dither: 0
+            }).toBuffer();
+            if (compact.length < output.length && (compact.length <= SHOP_BRAND_TARGET_OUTPUT_BYTES || output.length >= SHOP_BRAND_MAX_OUTPUT_BYTES)) output = compact;
+          }
+        } else {
+          for (const quality of [86, 76, 66, 56, 46]) {
+            const encoded = await build().jpeg({
+              quality,
+              mozjpeg: true,
+              chromaSubsampling: "4:2:0"
+            }).toBuffer();
+            if (!output || encoded.length < output.length) output = encoded;
+            if (encoded.length <= SHOP_BRAND_TARGET_OUTPUT_BYTES) break;
+          }
+        }
+      } catch (error) {
+        if (error instanceof ShopBrandMediaError) throw error;
+        throw new ShopBrandMediaError("INVALID_IMAGE");
+      }
+      if (!output || output.length >= SHOP_BRAND_MAX_OUTPUT_BYTES) {
+        throw new ShopBrandMediaError("OUTPUT_TOO_LARGE");
+      }
+      return verifyEncodedBrandImage(output, mime);
+    }
+  };
+}
+
+// src/commerce/presentation/node/product-image-transformer.ts
+import sharp3 from "sharp";
+var WIDTH = 1125;
+var HEIGHT = 600;
+var QUALITY_STEPS = [86, 76, 66, 56, 46];
+var SUPPORTED_SOURCES2 = /* @__PURE__ */ new Set(["jpeg", "png", "webp", "avif", "heif", "gif", "svg", "tiff"]);
+function createOutreachProductImageTransformer() {
+  return {
+    async transform(bytes, signal) {
+      if (signal?.aborted) throw new ShopBrandMediaError("SOURCE_TIMEOUT", true);
+      if (!Buffer.isBuffer(bytes) || bytes.length === 0) throw new ShopBrandMediaError("INVALID_IMAGE");
+      try {
+        if (bytes.subarray(0, 512).toString("utf8").replace(/^\uFEFF/, "").trimStart().startsWith("<")) {
+          assertSelfContainedSvg(bytes);
+        }
+        const source = sharp3(bytes, {
+          limitInputPixels: false,
+          failOn: "error",
+          animated: false,
+          pages: 1
+        });
+        const cancelSource = () => {
+          source.destroy();
+        };
+        signal?.addEventListener("abort", cancelSource, { once: true });
+        let info;
+        try {
+          info = await source.metadata();
+        } finally {
+          signal?.removeEventListener("abort", cancelSource);
+        }
+        if (signal?.aborted) throw new ShopBrandMediaError("SOURCE_TIMEOUT", true);
+        if (!info.format || !SUPPORTED_SOURCES2.has(info.format) || !info.width || !info.height) {
+          throw new ShopBrandMediaError("INVALID_IMAGE");
+        }
+        if (info.width * info.height > SHOP_BRAND_MAX_INPUT_PIXELS) {
+          throw new ShopBrandMediaError("INPUT_PIXELS_EXCEEDED");
+        }
+        if (info.format === "svg") assertSelfContainedSvg(bytes);
+        let output;
+        for (const quality of QUALITY_STEPS) {
+          if (signal?.aborted) throw new ShopBrandMediaError("SOURCE_TIMEOUT", true);
+          const encoder = sharp3(bytes, {
+            limitInputPixels: SHOP_BRAND_MAX_INPUT_PIXELS,
+            failOn: "error",
+            animated: false,
+            pages: 1
+          }).rotate().toColourspace("srgb").resize(WIDTH, HEIGHT, {
+            fit: "contain",
+            position: "centre",
+            background: { r: 255, g: 255, b: 255, alpha: 1 },
+            withoutEnlargement: false
+          }).flatten({ background: "#ffffff" }).removeAlpha().jpeg({ quality, mozjpeg: true, chromaSubsampling: "4:2:0" });
+          const cancelEncoder = () => {
+            encoder.destroy();
+          };
+          signal?.addEventListener("abort", cancelEncoder, { once: true });
+          let encoded;
+          try {
+            encoded = await encoder.toBuffer();
+          } finally {
+            signal?.removeEventListener("abort", cancelEncoder);
+          }
+          if (signal?.aborted) throw new ShopBrandMediaError("SOURCE_TIMEOUT", true);
+          if (!output || encoded.length < output.length) output = encoded;
+          if (encoded.length <= 1024 * 1024) break;
+        }
+        if (!output || output.length >= SHOP_BRAND_MAX_OUTPUT_BYTES) {
+          throw new ShopBrandMediaError("OUTPUT_TOO_LARGE");
+        }
+        const verified = await verifyEncodedBrandImage(output, "image/jpeg");
+        if (signal?.aborted) throw new ShopBrandMediaError("SOURCE_TIMEOUT", true);
+        if (verified.contentType !== "image/jpeg" || verified.width !== WIDTH || verified.height !== HEIGHT || verified.bytes.subarray(0, 2).toString("hex") !== "ffd8") {
+          throw new ShopBrandMediaError("OUTPUT_VERIFICATION_FAILED");
+        }
+        return verified;
+      } catch (error) {
+        if (error instanceof ShopBrandMediaError) throw error;
+        throw new ShopBrandMediaError("INVALID_IMAGE", false, boundedMediaProviderMessage(error));
+      }
+    }
+  };
+}
+
+// src/commerce/presentation/node/r2-writer.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client
+} from "@aws-sdk/client-s3";
+var SHOP_BRAND_CACHE_CONTROL = "public, max-age=31536000, immutable";
+function sanitizeR2ProviderMessage(error, credentials) {
+  if (!error || typeof error !== "object" || !("message" in error) || typeof error.message !== "string") return void 0;
+  let message = [...error.message].map((character) => {
+    const code = character.charCodeAt(0);
+    return code < 32 || code === 127 ? " " : character;
+  }).join("");
+  for (const secret of [credentials.secretAccessKey, credentials.accessKeyId]) {
+    if (secret) message = message.split(secret).join("[REDACTED]");
+  }
+  message = message.replace(/(authorization\s*[:=]\s*)(?:bearer\s+)?[^\s,;]+/gi, "$1[REDACTED]").replace(/\b(bearer\s+)[A-Za-z0-9._~+/-]+=*/gi, "$1[REDACTED]").replace(/((?:access.?key(?:.?id)?|secret.?key|session.?token|security.?token|token|password|signature|credential|api.?key)\s*[:=]\s*)[^\s,;&"'<>]+/gi, "$1[REDACTED]").replace(/\bhttps?:\/\/[^\s,;]+/gi, "[URL REDACTED]").replace(/\s+/g, " ").trim().slice(0, 300);
+  return message || void 0;
+}
+function createBrandR2S3Transport(credentials) {
+  const client = new S3Client({
+    endpoint: credentials.endpoint,
+    region: "auto",
+    forcePathStyle: true,
+    credentials: { accessKeyId: credentials.accessKeyId, secretAccessKey: credentials.secretAccessKey },
+    maxAttempts: 2
+  });
+  return {
+    close() {
+      client.destroy();
+    },
+    head(input, signal) {
+      return client.send(new HeadObjectCommand(input), signal ? { abortSignal: signal } : {});
+    },
+    async put(input, signal) {
+      await client.send(new PutObjectCommand(input), signal ? { abortSignal: signal } : {});
+    },
+    safeErrorMessage(error) {
+      return sanitizeR2ProviderMessage(error, credentials);
+    }
+  };
+}
+function httpStatus(error) {
+  if (!error || typeof error !== "object" || !("$metadata" in error)) return void 0;
+  const metadata = error.$metadata;
+  if (!metadata || typeof metadata !== "object" || !("httpStatusCode" in metadata)) return void 0;
+  return typeof metadata.httpStatusCode === "number" ? metadata.httpStatusCode : void 0;
+}
+function isMissing(error) {
+  if (httpStatus(error) === 404) return true;
+  return error !== null && typeof error === "object" && "name" in error && (error.name === "NotFound" || error.name === "NoSuchKey");
+}
+function r2Failure(error, transport) {
+  if (error instanceof ShopBrandMediaError) return error;
+  const status = httpStatus(error);
+  return new ShopBrandMediaError(
+    "R2_UNAVAILABLE",
+    status === void 0 || status >= 500 || status === 429 || status === 408 || status === 409,
+    transport.safeErrorMessage?.(error)
+  );
+}
+function validBucket(bucket) {
+  return /^(?!.*\.\.)(?!.*\.-|.*-\.)[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/.test(bucket) && !/^\d+\.\d+\.\d+\.\d+$/.test(bucket);
+}
+async function putGuardedImmutableR2Object(input) {
+  const { bucket, objectKey, image } = input;
+  const dimensions = input.expectedDimensions ?? { width: 1125, height: 600 };
+  if (!validBucket(bucket) || !input.acceptsKey(objectKey) || !["image/jpeg", "image/png"].includes(image.contentType) || !/^[a-f0-9]{64}$/.test(image.contentSha256) || createHash2("sha256").update(image.bytes).digest("hex") !== image.contentSha256 || image.sizeBytes !== image.bytes.length || !Number.isSafeInteger(dimensions.width) || !Number.isSafeInteger(dimensions.height) || dimensions.width <= 0 || dimensions.height <= 0 || dimensions.width * dimensions.height > 4e7 || image.width !== dimensions.width || image.height !== dimensions.height) {
+    throw new ShopBrandMediaError("OUTPUT_VERIFICATION_FAILED");
+  }
+  const transport = typeof input.transportOrFactory === "function" ? await input.transportOrFactory() : input.transportOrFactory;
+  const head = async () => {
+    try {
+      return input.signal ? await transport.head({ Bucket: bucket, Key: objectKey }, input.signal) : await transport.head({ Bucket: bucket, Key: objectKey });
+    } catch (error) {
+      if (isMissing(error)) return null;
+      throw r2Failure(error, transport);
+    }
+  };
+  let existing = await head();
+  if (existing === null) {
+    try {
+      const putInput = {
+        Bucket: bucket,
+        Key: objectKey,
+        Body: image.bytes,
+        ContentType: image.contentType,
+        ContentLength: image.sizeBytes,
+        CacheControl: SHOP_BRAND_CACHE_CONTROL,
+        Metadata: { sha256: image.contentSha256 },
+        IfNoneMatch: "*"
+      };
+      if (input.signal) await transport.put(putInput, input.signal);
+      else await transport.put(putInput);
+    } catch (error) {
+      if (httpStatus(error) !== 412 && httpStatus(error) !== 409) throw r2Failure(error, transport);
+    }
+    existing = await head();
+  }
+  if (existing === null) throw new ShopBrandMediaError("R2_UNAVAILABLE", true);
+  if (existing.ContentType !== image.contentType || existing.ContentLength !== image.sizeBytes || existing.Metadata?.sha256 !== image.contentSha256 || existing.CacheControl !== SHOP_BRAND_CACHE_CONTROL) {
+    throw new ShopBrandMediaError("R2_OBJECT_MISMATCH");
+  }
+}
+
+// src/commerce/presentation/node/public-probe.ts
+import { createHash as createHash3 } from "crypto";
+function createShopBrandPublicMediaProbe(fetcher) {
+  return {
+    async verify({ url, image }, signal) {
+      try {
+        const result = await fetcher.fetch(url, signal);
+        if (result.declaredContentType !== image.contentType || result.bytes.length !== image.sizeBytes || createHash3("sha256").update(result.bytes).digest("hex") !== image.contentSha256) {
+          throw new ShopBrandMediaError("PUBLIC_MEDIA_MISMATCH", true);
+        }
+      } catch (error) {
+        if (error instanceof ShopBrandMediaError && error.code === "PUBLIC_MEDIA_MISMATCH") throw error;
+        throw new ShopBrandMediaError(
+          "PUBLIC_MEDIA_UNAVAILABLE",
+          true,
+          (error instanceof ShopBrandMediaError ? error.providerMessage : void 0) ?? boundedMediaProviderMessage(error)
+        );
+      }
+    }
+  };
+}
+
+// src/commerce/presentation/node/product-image.ts
+import { createHash as createHash4 } from "crypto";
+import { isIP as isIP3 } from "net";
+var KEY = /^conversation-products\/v1\/[a-f0-9]{64}\/[a-f0-9]{64}\/[a-f0-9]{64}\.jpg$/;
+var isConversationProductObjectKey = (key) => KEY.test(key);
+var sha256 = (bytes) => createHash4("sha256").update(bytes).digest("hex");
+function conversationProductObjectKey(source, contentSha256) {
+  const parsed = ConversationProductImageSourceSchema.parse(source);
+  if (!/^[a-f0-9]{64}$/.test(contentSha256)) throw new ShopBrandMediaError("OUTPUT_VERIFICATION_FAILED");
+  return `conversation-products/v1/${sha256(parsed.shopId)}/${sha256(stableJson({ productId: parsed.productId, variantId: parsed.variantId }))}/${contentSha256}.jpg`;
+}
+function publicOrigin(value) {
+  try {
+    const url = new URL(value), host = url.hostname.replace(/^\[|\]$/g, "");
+    if (url.protocol !== "https:" || url.username || url.password || url.port || url.pathname !== "/" || url.search || url.hash || value !== url.origin && value !== url.origin + "/" || host === "localhost" || host.endsWith(".localhost") || isIP3(host) && !isPublicIpAddress(host)) return null;
+    return url.origin;
+  } catch {
+    return null;
+  }
+}
+var MediaDeadline = class extends Error {
+};
+function bounded(operation, signal) {
+  if (signal.aborted) return Promise.reject(new MediaDeadline());
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(new MediaDeadline());
+    signal.addEventListener("abort", abort, { once: true });
+    Promise.resolve().then(() => {
+      if (signal.aborted) throw new MediaDeadline();
+      return operation();
+    }).then(
+      (value) => {
+        signal.removeEventListener("abort", abort);
+        if (signal.aborted) reject(new MediaDeadline());
+        else resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", abort);
+        reject(error);
+      }
+    );
+  });
+}
+async function prepareConversationProductImage(input, deps = {}) {
+  const now = deps.now ?? Date.now, start = now();
+  const duration = () => {
+    const elapsed = now() - start;
+    return Number.isFinite(elapsed) ? Math.max(0, Math.min(5e3, elapsed)) : 0;
+  };
+  let stage = "CONFIGURATION";
+  const omitted = (reason) => ({ kind: "OMITTED", reason, stage, durationMs: duration() });
+  const budget = input.deadlineAt === void 0 ? 5e3 : Math.min(5e3, input.deadlineAt - start - 1e3);
+  if (!Number.isFinite(start) || !Number.isFinite(budget) || budget <= 0 || input.signal?.aborted) return omitted("MEDIA_DEADLINE");
+  const source = ConversationProductImageSourceSchema.safeParse(input.source);
+  if (!source.success) return omitted("UNSAFE_IMAGE_SOURCE");
+  const origin = publicOrigin(input.publicOrigin);
+  if (!origin || typeof input.bucketName !== "string" || !validBucket(input.bucketName) || typeof input.r2?.accessKeyId !== "string" || !input.r2.accessKeyId || typeof input.r2.secretAccessKey !== "string" || !input.r2.secretAccessKey) return omitted("CONFIGURATION_UNAVAILABLE");
+  try {
+    const endpoint = new URL(input.r2.endpoint);
+    if (endpoint.protocol !== "https:" || endpoint.username || endpoint.password || endpoint.search || endpoint.hash) return omitted("CONFIGURATION_UNAVAILABLE");
+  } catch {
+    return omitted("CONFIGURATION_UNAVAILABLE");
+  }
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  input.signal?.addEventListener("abort", abort, { once: true });
+  if (input.signal?.aborted) abort();
+  const timer = setTimeout(abort, budget);
+  const checkDeadline = () => {
+    if (now() >= start + budget) abort();
+    if (controller.signal.aborted) throw new MediaDeadline();
+  };
+  let transport;
+  try {
+    checkDeadline();
+    stage = "SOURCE";
+    const fetched = await bounded(() => (deps.fetcher ?? createSafeImageFetcher()).fetch(source.data.sourceUrl, controller.signal), controller.signal);
+    checkDeadline();
+    stage = "TRANSFORM";
+    const image = await bounded(() => (deps.transformer ?? createOutreachProductImageTransformer()).transform(fetched.bytes, controller.signal), controller.signal);
+    checkDeadline();
+    const objectKey = conversationProductObjectKey(source.data, image.contentSha256);
+    const prepared = ConversationPreparedProductImageSchema.parse({
+      schemaVersion: 1,
+      shopId: source.data.shopId,
+      productId: source.data.productId,
+      variantId: source.data.variantId,
+      publicUrl: `${origin}/${objectKey}`,
+      objectKey,
+      contentSha256: image.contentSha256,
+      contentType: image.contentType,
+      byteLength: image.sizeBytes,
+      width: image.width,
+      height: image.height
+    });
+    stage = "R2";
+    if (controller.signal.aborted) throw new MediaDeadline();
+    transport = (deps.transportFactory ?? createBrandR2S3Transport)(input.r2);
+    checkDeadline();
+    await bounded(() => putGuardedImmutableR2Object({
+      transportOrFactory: transport,
+      bucket: input.bucketName,
+      objectKey,
+      image,
+      acceptsKey: (key) => isConversationProductObjectKey(key) && key === objectKey,
+      signal: controller.signal
+    }), controller.signal);
+    checkDeadline();
+    stage = "PUBLIC_PROBE";
+    const probe = deps.probe ?? createShopBrandPublicMediaProbe(createSafeImageFetcher({ maxRedirects: 0, maxBytes: 5 * 1024 * 1024 - 1 }));
+    await bounded(() => probe.verify({ url: prepared.publicUrl, image }, controller.signal), controller.signal);
+    checkDeadline();
+    stage = "READY";
+    return { kind: "READY", image: prepared, stage, durationMs: duration() };
+  } catch (error) {
+    if (controller.signal.aborted || error instanceof MediaDeadline || now() >= start + budget) return omitted("MEDIA_DEADLINE");
+    if (stage === "SOURCE") return omitted(error instanceof ShopBrandMediaError && error.code === "UNSAFE_SOURCE" ? "UNSAFE_IMAGE_SOURCE" : "SOURCE_UNAVAILABLE");
+    if (stage === "TRANSFORM") return omitted("IMAGE_TRANSFORM_FAILED");
+    return omitted(stage === "PUBLIC_PROBE" ? "PUBLIC_IMAGE_UNAVAILABLE" : "R2_UNAVAILABLE");
+  } finally {
+    clearTimeout(timer);
+    input.signal?.removeEventListener("abort", abort);
+    try {
+      transport?.close?.();
+    } catch {
+    }
+  }
+}
+export {
+  MERCHANT_KNOWLEDGE_ACQUISITION_ERROR_CODES,
+  MerchantKnowledgeAcquisitionError,
+  SHOP_BRAND_CACHE_CONTROL,
+  SHOP_BRAND_CANVAS,
+  SHOP_BRAND_MAX_INPUT_PIXELS,
+  SHOP_BRAND_MAX_OUTPUT_BYTES,
+  SHOP_BRAND_MAX_SOURCE_BYTES,
+  SHOP_BRAND_TARGET_OUTPUT_BYTES,
+  ShopBrandMediaError,
+  addressesMatch,
+  assertSelfContainedSvg,
+  boundedMediaProviderMessage,
+  conversationProductObjectKey,
+  createBrandR2S3Transport,
+  createOutreachProductImageTransformer,
+  createPinnedLookup,
+  createSafeImageFetcher,
+  createShopBrandImageTransformer,
+  createShopBrandPublicMediaProbe,
+  isConversationProductObjectKey,
+  isPublicIpAddress,
+  validBucket as isValidMediaBucket,
+  normalizeIpAddress,
+  prepareConversationProductImage,
+  putGuardedImmutableR2Object,
+  resolveAllDnsAnswers,
+  resolveAndValidateDestination,
+  sanitizeR2ProviderMessage,
+  verifyEncodedBrandImage
+};
+//# sourceMappingURL=index.js.map