@sonordev/site-kit 6.5.0 → 7.0.0

package/dist/chunk-UINSEWQ3.js

@@ -0,0 +1,127 @@
+import { resolveFetch } from './chunk-VX5CMNMM.js';
+import { monotonicMs } from './chunk-MH2DSGC6.js';
+import { SITE_KIT_VERSION } from './chunk-7ZHJIRM3.js';
+import 'server-only';
+
+var MINT_PATH = "/api/public/site-token";
+var MINT_TIMEOUT_MS = 4e3;
+var SITE_TOKEN_PREFIX = "st1.";
+var MINT_MAX_ATTEMPTS = 4;
+var MINT_BACKOFF_BASE_MS = 500;
+var MINT_BACKOFF_CAP_MS = 8e3;
+var cache = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Map();
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function retryDelayMs(res, attempt) {
+  const header = res?.headers?.get?.("retry-after");
+  if (header) {
+    const seconds = Number(header);
+    const ms = Number.isFinite(seconds) ? seconds * 1e3 : NaN;
+    if (Number.isFinite(ms) && ms > 0) return Math.min(ms, MINT_BACKOFF_CAP_MS);
+  }
+  return Math.min(MINT_BACKOFF_BASE_MS * 2 ** attempt, MINT_BACKOFF_CAP_MS);
+}
+var isRetryableStatus = (status) => status === 429 || status >= 500;
+function rawFallbackAllowed() {
+  return typeof process !== "undefined" && process.env?.SONOR_SITE_TOKEN_FALLBACK === "raw";
+}
+function failClosed(reason, rawKey, now) {
+  if (rawFallbackAllowed()) {
+    console.warn(
+      `[SiteKitLayout] Token mint failed (${reason}) and SONOR_SITE_TOKEN_FALLBACK=raw is set; injecting the RAW API KEY into page HTML. The key is publicly readable wherever this page is served \u2014 unset the escape hatch once the mint is healthy.`
+    );
+    cache.set(rawKey, { credential: rawKey, expiresAt: now + 6e4 });
+    return rawKey;
+  }
+  throw new Error(
+    `site-kit: could not mint a site token (${reason}). Refusing to publish the raw SONOR_API_KEY in page HTML, so this build fails instead. Check that the mint endpoint is reachable and the key is valid, then rebuild. To ship anyway \u2014 which publishes the project secret in public HTML \u2014 set SONOR_SITE_TOKEN_FALLBACK=raw.`
+  );
+}
+function isFrameworkSignal(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e.digest === "DYNAMIC_SERVER_USAGE") return true;
+  if (e.code === "NEXT_STATIC_GEN_BAILOUT") return true;
+  if (typeof e.digest === "string" && e.digest.startsWith("NEXT_")) return true;
+  if (e.$$typeof === /* @__PURE__ */ Symbol.for("react.postpone")) return true;
+  return false;
+}
+async function resolveClientCredential(rawKey, apiUrl) {
+  if (!rawKey) return "";
+  if (rawKey.startsWith(SITE_TOKEN_PREFIX)) return rawKey;
+  const cached = cache.get(rawKey);
+  if (cached && cached.expiresAt > monotonicMs()) return cached.credential;
+  const pending = inflight.get(rawKey);
+  if (pending) return pending;
+  const request = mintWithRetry(rawKey, apiUrl);
+  inflight.set(rawKey, request);
+  try {
+    return await request;
+  } finally {
+    inflight.delete(rawKey);
+  }
+}
+async function mintWithRetry(rawKey, apiUrl) {
+  const base = (apiUrl || "https://api.sonor.io").replace(/\/+$/, "");
+  let lastReason = "unknown error";
+  for (let attempt = 0; attempt < MINT_MAX_ATTEMPTS; attempt++) {
+    let res = null;
+    try {
+      const { fn: fetchFn, unpatched } = resolveFetch();
+      res = await fetchFn(`${base}${MINT_PATH}`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-api-key": rawKey,
+          "x-sitekit-version": SITE_KIT_VERSION
+        },
+        // Only meaningful on the fallback path, where a future Next stopped
+        // exposing `_nextOriginalFetch` and we're back on the patched fetch.
+        // `revalidate: false` is the one setting that neither bails out of static
+        // generation nor downgrades the route to ISR; a Data Cache entry is the
+        // lesser evil versus shipping the raw key again.
+        ...unpatched ? {} : { next: { revalidate: false } },
+        signal: typeof AbortSignal !== "undefined" && AbortSignal.timeout ? AbortSignal.timeout(MINT_TIMEOUT_MS) : void 0
+      });
+    } catch (err) {
+      if (isFrameworkSignal(err)) throw err;
+      lastReason = err instanceof Error ? err.message : "network error";
+      if (attempt < MINT_MAX_ATTEMPTS - 1) {
+        await sleep(retryDelayMs(null, attempt));
+        continue;
+      }
+      break;
+    }
+    if (res.ok) {
+      const data = await res.json().catch(() => null);
+      const token = data?.token;
+      const expiresIn = typeof data?.expiresIn === "number" ? data.expiresIn : 3600;
+      if (typeof token === "string" && token.startsWith(SITE_TOKEN_PREFIX)) {
+        cache.set(rawKey, {
+          credential: token,
+          expiresAt: monotonicMs() + Math.min(expiresIn * 1e3 / 2, 30 * 6e4)
+        });
+        return token;
+      }
+      lastReason = "mint returned no usable token";
+      break;
+    }
+    if (res.status === 404) {
+      cache.set(rawKey, { credential: rawKey, expiresAt: monotonicMs() + 6e4 });
+      return rawKey;
+    }
+    lastReason = `HTTP ${res.status}`;
+    if (isRetryableStatus(res.status) && attempt < MINT_MAX_ATTEMPTS - 1) {
+      const delay = retryDelayMs(res, attempt);
+      console.warn(
+        `[SiteKitLayout] Token mint returned ${res.status}; retrying in ${Math.round(delay)}ms (attempt ${attempt + 2}/${MINT_MAX_ATTEMPTS}).`
+      );
+      await sleep(delay);
+      continue;
+    }
+    break;
+  }
+  return failClosed(lastReason, rawKey, monotonicMs());
+}
+
+export { resolveClientCredential };

package/dist/chunk-UPFU63L4.js

@@ -0,0 +1,126 @@
+'use client';
+import { trackEvent } from './chunk-LCDVPAMR.js';
+import { useRef, useEffect } from 'react';
+import { usePathname } from 'next/navigation';
+import { jsx } from 'react/jsx-runtime';
+
+var DIRECTION_THRESHOLD = 8;
+var TOP_ZONE = 80;
+function nextCompactState(state, y) {
+  if (y <= TOP_ZONE) return { compact: false, anchorY: y };
+  const delta = y - state.anchorY;
+  if (Math.abs(delta) < DIRECTION_THRESHOLD) return state;
+  return { compact: delta > 0, anchorY: y };
+}
+var NON_TEXT_INPUTS = /* @__PURE__ */ new Set(["button", "checkbox", "color", "file", "hidden", "image", "radio", "range", "reset", "submit"]);
+function isTextEntry(el) {
+  if (!el) return false;
+  const tag = el.tagName;
+  if (tag === "TEXTAREA" || tag === "SELECT") return true;
+  if (el.isContentEditable) return true;
+  if (tag === "INPUT") return !NON_TEXT_INPUTS.has((el.type || "text").toLowerCase());
+  return false;
+}
+function setFlag(el, name, on) {
+  if (on) {
+    if (!el.hasAttribute(name)) el.setAttribute(name, "");
+  } else if (el.hasAttribute(name)) {
+    el.removeAttribute(name);
+  }
+}
+function CtaBarBehavior({ showAfter, hideOver, hideWhileTyping, compactOnScroll, track }) {
+  const anchorRef = useRef(null);
+  const pathname = usePathname();
+  const hideOverKey = (hideOver ?? []).join("\n");
+  useEffect(() => {
+    const bar = anchorRef.current?.closest("[data-sk-cta-bar]");
+    if (!bar) return;
+    const state = { beforeStart: false, overTarget: false, typing: false };
+    const sync = () => setFlag(bar, "data-hidden", state.beforeStart || state.overTarget || state.typing);
+    const cleanups = [];
+    const start = showAfter ? document.querySelector(showAfter) : null;
+    if (start && "IntersectionObserver" in window) {
+      state.beforeStart = true;
+      const io = new IntersectionObserver(([entry]) => {
+        state.beforeStart = entry.isIntersecting || entry.boundingClientRect.top > 0;
+        sync();
+      });
+      io.observe(start);
+      cleanups.push(() => io.disconnect());
+    }
+    const targets = hideOverKey ? hideOverKey.split("\n").flatMap((sel) => Array.from(document.querySelectorAll(sel))) : [];
+    if (targets.length && "IntersectionObserver" in window) {
+      const showing = /* @__PURE__ */ new Set();
+      const io = new IntersectionObserver((entries) => {
+        for (const e of entries) {
+          if (e.isIntersecting) showing.add(e.target);
+          else showing.delete(e.target);
+        }
+        state.overTarget = showing.size > 0;
+        sync();
+      });
+      targets.forEach((t) => io.observe(t));
+      cleanups.push(() => io.disconnect());
+    }
+    if (hideWhileTyping) {
+      const onFocusIn = (e) => {
+        state.typing = isTextEntry(e.target);
+        sync();
+      };
+      const onFocusOut = () => {
+        queueMicrotask(() => {
+          state.typing = isTextEntry(document.activeElement);
+          sync();
+        });
+      };
+      document.addEventListener("focusin", onFocusIn);
+      document.addEventListener("focusout", onFocusOut);
+      cleanups.push(() => {
+        document.removeEventListener("focusin", onFocusIn);
+        document.removeEventListener("focusout", onFocusOut);
+      });
+    }
+    if (compactOnScroll) {
+      let compactState = { compact: false, anchorY: window.scrollY };
+      let frame = 0;
+      const onScroll = () => {
+        if (frame) return;
+        frame = requestAnimationFrame(() => {
+          frame = 0;
+          compactState = nextCompactState(compactState, window.scrollY);
+          setFlag(bar, "data-compact", compactState.compact);
+        });
+      };
+      window.addEventListener("scroll", onScroll, { passive: true });
+      cleanups.push(() => {
+        window.removeEventListener("scroll", onScroll);
+        if (frame) cancelAnimationFrame(frame);
+        setFlag(bar, "data-compact", false);
+      });
+    }
+    if (track) {
+      const onClick = (e) => {
+        const action = e.target?.closest(".sk-cta-bar__action");
+        if (!action || !bar.contains(action)) return;
+        trackEvent({
+          name: "cta_click",
+          category: "engagement",
+          label: action.textContent?.trim() || void 0,
+          properties: {
+            location: "cta_bar",
+            href: action.getAttribute("href") ?? void 0,
+            variant: action.getAttribute("data-variant") ?? void 0,
+            compact: bar.hasAttribute("data-compact")
+          }
+        });
+      };
+      bar.addEventListener("click", onClick);
+      cleanups.push(() => bar.removeEventListener("click", onClick));
+    }
+    sync();
+    return () => cleanups.forEach((fn) => fn());
+  }, [pathname, showAfter, hideOverKey, hideWhileTyping, compactOnScroll, track]);
+  return /* @__PURE__ */ jsx("span", { ref: anchorRef, hidden: true });
+}
+
+export { CtaBarBehavior, isTextEntry, nextCompactState };

package/dist/chunk-UVPGW4R7.js

@@ -0,0 +1,222 @@
+import { OG_HEIGHT, OG_WIDTH, TITLE_MAX_PX, barTextColor, TITLE_MIN_PX, OG_REPORT_ATTR } from './chunk-LE7ZOTHB.js';
+import { applyTrailingSlash, resolveTrailingSlash } from './chunk-YVKRYQRG.js';
+
+// src/og/template.ts
+function fitScript() {
+  return `<script>
+(async function () {
+  var report = { fits: true, titlePx: ${TITLE_MAX_PX}, issues: [] };
+  function push(msg) { report.fits = false; report.issues.push(msg); }
+  try {
+    try { await document.fonts.ready; } catch (e) {}
+    var h1 = document.querySelector('h1');
+    var copy = document.querySelector('.copy');
+    var wrap = document.querySelector('.wrap');
+    var bar = document.querySelector('.bar');
+
+    if (h1 && copy && wrap) {
+      var cs = getComputedStyle(wrap);
+      var avail = wrap.clientHeight - parseFloat(cs.paddingTop || '0') - parseFloat(cs.paddingBottom || '0');
+
+      // Fit BOTH axes. Height alone is not enough: a single long word
+      // ("WORKBENCHES") cannot wrap, so it keeps overflowing the column
+      // sideways at a size that fits vertically. Shrinking for either
+      // condition is what makes an arbitrary managed title safe to render.
+      var tooTall = function () { return copy.scrollHeight > avail; };
+      var tooWide = function () { return h1.scrollWidth > copy.clientWidth + 1; };
+      var size = ${TITLE_MAX_PX};
+      while (size > ${TITLE_MIN_PX} && (tooTall() || tooWide())) {
+        size -= 2;
+        h1.style.fontSize = size + 'px';
+      }
+      report.titlePx = size;
+
+      if (tooTall()) {
+        push('title/subtitle block overflows the card by ' + Math.ceil(copy.scrollHeight - avail) +
+             'px even at the ' + ${TITLE_MIN_PX} + 'px legibility floor - shorten content.title or content.subtitle');
+      }
+      if (tooWide()) {
+        push('the longest title word still overflows the copy column by ' + Math.ceil(h1.scrollWidth - copy.clientWidth) +
+             'px at the ' + ${TITLE_MIN_PX} + 'px floor - shorten it or add a line break');
+      }
+    }
+
+    // The bar is checked on BOTH axes. Width alone missed a real failure: a
+    // long segment wrapped INSIDE its span, so scrollWidth never exceeded
+    // clientWidth while the text grew past the bar's fixed height and spilled
+    // over the subtitle. Segments are nowrap now, which turns that into
+    // horizontal overflow the width check sees, and the height check is the
+    // belt-and-braces for anything else that grows the bar.
+    if (bar) {
+      if (bar.scrollWidth > bar.clientWidth + 1) {
+        push('bottom bar content overflows by ' + Math.ceil(bar.scrollWidth - bar.clientWidth) +
+             'px - drop a content.bar segment or shorten one');
+      }
+      if (bar.scrollHeight > bar.clientHeight + 1) {
+        push('bottom bar content is ' + Math.ceil(bar.scrollHeight - bar.clientHeight) +
+             'px taller than the bar - a segment is wrapping; shorten it');
+      }
+    }
+
+    // Nothing may sit outside the frame platforms actually crop to.
+    var named = [['kicker', '.kicker'], ['title', 'h1'], ['subtitle', '.sub'], ['hand', '.hand'], ['bar', '.bar']];
+    for (var i = 0; i < named.length; i++) {
+      var el = document.querySelector(named[i][1]);
+      if (!el) continue;
+      var r = el.getBoundingClientRect();
+      if (r.top < -1 || r.bottom > ${OG_HEIGHT} + 1) {
+        push(named[i][0] + ' sits outside the ' + ${OG_HEIGHT} + 'px frame (top ' +
+             Math.round(r.top) + ', bottom ' + Math.round(r.bottom) + ')');
+      }
+    }
+  } catch (e) {
+    push('fitter failed: ' + (e && e.message ? e.message : String(e)));
+  }
+  document.documentElement.setAttribute('${OG_REPORT_ATTR}', JSON.stringify(report));
+})();
+</script>`;
+}
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function fontLink(config) {
+  const fonts = config.fonts?.length ? config.fonts : [{ family: "Barlow Condensed", weights: [800] }];
+  const families = fonts.map((f) => `family=${f.family.replace(/ /g, "+")}:wght@${(f.weights || [700]).join(";")}`).join("&");
+  return `<link href="https://fonts.googleapis.com/css2?${families}&display=block" rel="stylesheet">`;
+}
+function displayFamily(config) {
+  return config.fonts?.[0]?.family || "Barlow Condensed";
+}
+function handFamily(config) {
+  const fonts = config.fonts || [];
+  return fonts.length > 1 ? fonts[fonts.length - 1].family : displayFamily(config);
+}
+function muted(theme) {
+  return theme.muted || theme.text;
+}
+function backgroundLayers(config) {
+  if (!config.background) return "";
+  const { image, blur = 0, scrim } = config.background;
+  return `
+  <div class="bg"><img src="${esc(image)}" style="filter:blur(${blur}px)"></div>
+  ${scrim ? `<div class="scrim" style="background:${esc(scrim)}"></div>` : ""}`;
+}
+function barHtml(content, theme) {
+  if (!content.bar?.length) return "";
+  const segs = content.bar.map((s) => `<span>${esc(s)}</span>`).join('<span class="dot"></span>');
+  return `<div class="bar" style="background:${esc(theme.accent)}">${segs}</div>`;
+}
+function copyHtml(config) {
+  const { content, theme } = config;
+  const titleHtml = esc(content.title).replace(/\n/g, "<br>");
+  const mark = config.logo && (config.layout ?? (config.logo ? "plate-left" : "banner")) === "split" ? `<img class="mark" src="${esc(config.logo)}">` : "";
+  return `
+    <div class="copy">
+      ${mark}
+      ${content.kicker ? `<div class="kicker">${esc(content.kicker)}</div>` : ""}
+      <h1>${titleHtml}</h1>
+      ${content.subtitle ? `<div class="sub" style="color:${esc(muted(theme))}">${esc(content.subtitle)}</div>` : ""}
+      ${content.hand ? `<div class="hand" style="font-family:'${esc(handFamily(config))}',cursive">${esc(content.hand)}</div>` : ""}
+    </div>`;
+}
+function buildOgHtml(config) {
+  if (config.html) return config.html;
+  if (config.template) {
+    return config.template(config, {
+      esc,
+      fontLink: fontLink(config),
+      width: OG_WIDTH,
+      height: OG_HEIGHT
+    });
+  }
+  const { theme, logo, layout = logo ? "plate-left" : "banner" } = config;
+  const display = displayFamily(config);
+  const plate = logo ? `<div class="plate" style="background:${esc(theme.surface)}"><img src="${esc(logo)}"></div>` : "";
+  const photo = config.photo ? `<div class="photo" style="flex-basis:${config.photo.width ?? 430}px;border-radius:${config.photo.radius ?? 24}px"><img src="${esc(config.photo.src)}"></div>` : "";
+  const body = layout === "centered" ? `<div class="wrap centered">${plate}${copyHtml(config)}</div>` : layout === "banner" ? `<div class="wrap banner">${copyHtml(config)}</div>` : layout === "split" ? `<div class="wrap">${copyHtml(config)}${photo}</div>` : `<div class="wrap">${photo || plate}${copyHtml(config)}</div>`;
+  return `<!doctype html>
+<html><head><meta charset="utf-8">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+${fontLink(config)}
+<style>
+  * { margin:0; padding:0; box-sizing:border-box; }
+  html,body { width:${OG_WIDTH}px; height:${OG_HEIGHT}px; overflow:hidden; }
+  body { position:relative; background:${theme.bg}; font-family:'${display}',sans-serif; color:${theme.text}; }
+  .bg { position:absolute; inset:0; }
+  .bg img { width:100%; height:100%; object-fit:cover; transform:scale(1.05); }
+  .scrim { position:absolute; inset:0; }
+  .wrap { position:relative; height:100%; display:flex; align-items:center; gap:52px; padding:0 68px ${config.content.bar?.length ? "74px" : "0"}; }
+  .wrap.centered { flex-direction:column; justify-content:center; text-align:center; gap:28px; }
+  .wrap.banner { padding-left:90px; }
+  .plate { border-radius:28px; padding:26px; flex:0 0 auto; }
+  .plate img { display:block; width:250px; height:auto; }
+  .centered .plate img { width:180px; }
+  .photo { flex:0 0 auto; height:76%; overflow:hidden; box-shadow:0 8px 40px rgba(0,0,0,.25); }
+  .photo img { width:100%; height:100%; object-fit:cover; display:block; }
+  .copy { flex:1 1 auto; min-width:0; }
+  /* split-layout brand mark: the photo owns the right pane, so the logo rides
+     above the kicker rather than being dropped. */
+  .mark { display:block; height:44px; width:auto; margin-bottom:20px; }
+  .kicker { font-weight:800; text-transform:uppercase; letter-spacing:.22em; font-size:24px; color:${theme.accent}; margin-bottom:14px; }
+  /* Opening size only \u2014 the in-page fitter steps this down to fit the frame. */
+  h1 { font-weight:800; text-transform:uppercase; font-size:${TITLE_MAX_PX}px; line-height:.9; letter-spacing:-.01em; }
+  .sub { margin-top:22px; font-size:29px; font-weight:500; line-height:1.32; }
+  /* Never below 40px: script faces are illegible at thumbnail width under that. */
+  .hand { font-size:42px; margin-top:14px; transform:rotate(-1.5deg); display:inline-block; }
+  .bar { position:absolute; left:0; right:0; bottom:0; height:74px; display:flex; align-items:center; justify-content:center; gap:26px;
+         font-weight:800; text-transform:uppercase; letter-spacing:.1em; font-size:31px; color:${barTextColor(theme)}; }
+  /* nowrap so an over-long segment overflows the bar sideways, where the
+     fitter's width check sees it, instead of silently wrapping to a second
+     line and spilling over the copy above. */
+  .bar > span { white-space:nowrap; }
+  .bar .dot { width:10px; height:10px; border-radius:50%; background:currentColor; opacity:.55; flex:0 0 auto; }
+</style></head>
+<body>
+${backgroundLayers(config)}
+${body}
+${barHtml(config.content, theme)}
+${fitScript()}
+</body></html>`;
+}
+
+// src/og/pages.ts
+function pathSegments(path) {
+  return path.split("/").filter(Boolean);
+}
+function bareRoute(path) {
+  const segments = pathSegments(path);
+  return segments.length ? `/${segments.join("/")}` : "/";
+}
+var PARAM_CARD_DIR = "_og";
+function paramCardUrl(path) {
+  const segments = pathSegments(path);
+  return `/${PARAM_CARD_DIR}/${segments.length ? segments.join("/") : "home"}.jpg`;
+}
+function paramCardImage(path, options = {}) {
+  if (options.config) {
+    const bare = bareRoute(path);
+    const cards = options.config.cards ?? {};
+    if (!cards[bare] && !cards[`${bare}/`]) return void 0;
+  }
+  return {
+    url: paramCardUrl(path),
+    width: OG_WIDTH,
+    height: OG_HEIGHT,
+    type: "image/jpeg",
+    ...options.alt && { alt: options.alt }
+  };
+}
+function codeCardImage(path, options = {}) {
+  const base = bareRoute(path);
+  const url = applyTrailingSlash(`${base === "/" ? "" : base}/opengraph-image`, resolveTrailingSlash(options.trailingSlash));
+  return {
+    url,
+    width: OG_WIDTH,
+    height: OG_HEIGHT,
+    type: options.contentType ?? "image/png",
+    ...options.alt && { alt: options.alt }
+  };
+}
+
+export { PARAM_CARD_DIR, buildOgHtml, codeCardImage, paramCardImage, paramCardUrl };

package/dist/chunk-VX5CMNMM.js

@@ -0,0 +1,26 @@
+// src/shared/fresh-fetch.ts
+function resolveFetch() {
+  const current = globalThis.fetch;
+  if (!current) throw new Error("site-kit: global fetch is unavailable");
+  const original = current._nextOriginalFetch;
+  if (typeof original === "function") return { fn: original, unpatched: true };
+  return { fn: current, unpatched: false };
+}
+var BUILD_NONCE = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+var FRESH_FETCH_NONCE_HEADER = "x-sitekit-build-nonce";
+function freshFetch(input, init = {}) {
+  const current = globalThis.fetch;
+  const { fn, unpatched } = resolveFetch();
+  if (unpatched || !current?.__nextPatched) return fn(input, init);
+  const headers = new Headers(init.headers);
+  headers.set(FRESH_FETCH_NONCE_HEADER, BUILD_NONCE);
+  return fn(input, { ...init, headers });
+}
+function isNextProductionBuild() {
+  return typeof process !== "undefined" && process.env?.NEXT_PHASE === "phase-production-build";
+}
+function buildFetch(input, init = {}) {
+  return isNextProductionBuild() ? freshFetch(input, init) : fetch(input, init);
+}
+
+export { buildFetch, freshFetch, resolveFetch };