@swell/apps-sdk 1.0.160 → 1.0.162

package/dist/index.mjs

@@ -7291,12 +7291,7 @@ var ThemeCache = class extends Cache {
   }
 };
 
-// src/cache/theme-file-storage.ts
-import bluebird2 from "bluebird";
-
 // src/cache/kv-variety.ts
-import bluebird from "bluebird";
-var { Promise: Promise2 } = bluebird;
 var CFKV = class {
   constructor(kv) {
     this.kv = kv;
@@ -7328,13 +7323,11 @@ var MiniflareKV = class {
       return /* @__PURE__ */ new Map();
     }
     const result = /* @__PURE__ */ new Map();
-    await Promise2.map(
-      keys,
-      async (key) => {
+    await Promise.all(
+      keys.map(async (key) => {
         const value = await this.kv.get(key, "text");
         result.set(key, value);
-      },
-      { concurrency: 50 }
+      })
     );
     return result;
   }
@@ -7366,16 +7359,13 @@ function createClientKV(env, flavor = "cf") {
   return new MemoryKV();
 }
 
-// src/cache/theme-file-storage.ts
-var { Promise: Promise3 } = bluebird2;
-var ThemeFileStorage = class {
+// src/cache/theme-file-cache.ts
+var ThemeFileCache = class {
   kv;
-  maxConcurrency;
   maxBatchSize = 20 * 1024 * 1024;
   // 20MB safety margin
   constructor(env, flavor = "cf") {
     this.kv = createClientKV(env, flavor);
-    this.maxConcurrency = flavor === "miniflare" ? 50 : 6;
   }
   /**
    * Build a KV storage key from a file hash
@@ -7468,10 +7458,8 @@ var ThemeFileStorage = class {
       totalSize,
       trace
     });
-    const results = await Promise3.map(
-      batches,
-      (batch) => this.loadBatch(batch),
-      { concurrency: Math.min(this.maxConcurrency, batches.length) }
+    const results = await Promise.all(
+      batches.map((batch) => this.loadBatch(batch))
     );
     const mergedConfigs = this.mergeResults(configs, results);
     const loadedCount = mergedConfigs.filter((c) => c.file_data).length;
@@ -7536,10 +7524,8 @@ var ThemeFileStorage = class {
     }
     const existing = /* @__PURE__ */ new Set();
     const batches = this.planGetBatches(configs);
-    const results = await Promise3.map(
-      batches,
-      (batch) => this.kv.get(batch.keys),
-      { concurrency: this.maxConcurrency }
+    const results = await Promise.all(
+      batches.map((batch) => this.kv.get(batch.keys))
     );
     for (const batchResult of results) {
       for (const [key, value] of batchResult.entries()) {
@@ -7603,15 +7589,13 @@ var ThemeFileStorage = class {
         skippedExisting: existing.size,
         trace
       });
-      await Promise3.map(
-        toWrite,
-        async (config) => {
+      await Promise.all(
+        toWrite.map(async (config) => {
           const key = this.buildKey(config.hash);
           const metadata = config.file?.content_type ? { content_type: config.file.content_type } : void 0;
-          await this.kv.put(key, config.file_data, metadata);
+          await this.kv.put(key, config.file_data, { metadata });
           result.written++;
-        },
-        { concurrency: this.maxConcurrency }
+        })
       );
     }
     logger.info("[ThemeFileStorage] Put files complete", {
@@ -7625,378 +7609,6 @@ var ThemeFileStorage = class {
   }
 };
 
-// src/cache/constants.ts
-var SECOND = 1e3;
-var MINUTE = 60 * SECOND;
-var HOUR = 60 * MINUTE;
-var DAY = 24 * HOUR;
-var YEAR = 365 * DAY;
-var SHORT_TTL = 5 * SECOND;
-
-// src/cache/worker-html-cache.ts
-var CACHE_NAME = "swell-html-v0";
-var CACHE_KEY_ORIGIN = "https://cache.swell.store";
-var TTL_CONFIG = {
-  LIVE: {
-    DEFAULT: 20,
-    HOME: 20,
-    PRODUCT: 20,
-    COLLECTION: 20,
-    PAGE: 20,
-    BLOG: 20,
-    SWR: 180
-  },
-  PREVIEW: {
-    DEFAULT: 20,
-    HOME: 20,
-    PRODUCT: 20,
-    COLLECTION: 20,
-    PAGE: 20,
-    BLOG: 20,
-    SWR: 180
-  }
-};
-var WorkerHtmlCache = class {
-  epoch;
-  constructor(epoch) {
-    this.epoch = epoch;
-  }
-  async get(request) {
-    const trace = createTraceId();
-    if (request.method !== "GET") {
-      logger.debug("[SDK Html-cache] non-cacheable", { trace });
-      return { found: false, cacheable: false };
-    }
-    if (!this.isCacheable(request)) {
-      logger.debug("[SDK Html-cache] non-cacheable", { trace });
-      return { found: false, cacheable: false };
-    }
-    try {
-      const cache = await caches.open(CACHE_NAME + this.epoch);
-      const cacheKey = this.buildCacheKey(request);
-      const cached = await cache.match(cacheKey);
-      if (!cached) {
-        logger.debug("[SDK Html-cache] cacheable, MISS", { trace });
-        return { found: false, cacheable: true };
-      }
-      const age = this.getResponseAge(cached);
-      const ttl = parseInt(cached.headers.get("X-Original-TTL") || "") || this.getTTLForRequest(request);
-      const swr = parseInt(cached.headers.get("X-Original-SWR") || "") || this.getSWRForRequest(request);
-      const isStale = age >= ttl;
-      const isExpired = age >= ttl + swr;
-      if (!isExpired) {
-        logger.debug("[SDK Html-cache] cacheable, HIT", {
-          stale: isStale,
-          age,
-          trace
-        });
-        const clientResponse = this.buildClientResponse(
-          cached,
-          ttl,
-          swr,
-          isStale,
-          age
-        );
-        return {
-          found: true,
-          stale: isStale,
-          response: clientResponse,
-          cacheable: true,
-          age: Math.floor(age)
-        };
-      }
-      logger.debug("[SDK Html-cache] cacheable, hit, expired", { trace });
-      return { found: false, cacheable: true };
-    } catch (_) {
-      logger.warn("[SDK Html-cache] no get support", { trace });
-      return null;
-    }
-  }
-  // 304 support
-  async getWithConditionals(request) {
-    const result = await this.get(request);
-    if (!result?.found || result.stale) {
-      return result;
-    }
-    const ifModifiedSince = request.headers.get("If-Modified-Since");
-    const ifNoneMatch = request.headers.get("If-None-Match");
-    if ((ifModifiedSince || ifNoneMatch) && result.response) {
-      const lastModified = result.response.headers.get("Last-Modified");
-      const etag = result.response.headers.get("ETag");
-      if (this.checkNotModified(ifModifiedSince, ifNoneMatch, lastModified, etag)) {
-        result.notModified = true;
-        result.conditional304 = new Response(null, {
-          status: 304,
-          headers: {
-            "Last-Modified": lastModified || "",
-            ETag: etag || "",
-            "Cache-Control": result.response.headers.get("Cache-Control") || "",
-            "Cloudflare-CDN-Cache-Control": result.response.headers.get("Cloudflare-CDN-Cache-Control") || "",
-            "X-Cache-Status": "HIT-304"
-          }
-        });
-      }
-    }
-    return result;
-  }
-  checkNotModified(ifModifiedSince, ifNoneMatch, lastModified, etag) {
-    if (ifNoneMatch && etag) {
-      return ifNoneMatch === etag;
-    }
-    if (ifModifiedSince && lastModified) {
-      const ifModDate = new Date(ifModifiedSince);
-      const lastModDate = new Date(lastModified);
-      return !isNaN(ifModDate.getTime()) && !isNaN(lastModDate.getTime()) && ifModDate >= lastModDate;
-    }
-    return false;
-  }
-  createRevalidationRequest(request) {
-    const headers = new Headers(request.headers);
-    headers.set("X-Cache-Bypass", "revalidation");
-    headers.delete("If-None-Match");
-    headers.delete("If-Modified-Since");
-    headers.delete("Cache-Control");
-    headers.delete("Pragma");
-    return new Request(request.url, {
-      method: "GET",
-      headers
-    });
-  }
-  async put(request, response) {
-    const trace = createTraceId();
-    if (request.method !== "GET" || !response.ok) {
-      logger.debug("[SDK Html-cache] put skipped", { trace });
-      return;
-    }
-    if (!this.isCacheable(request) || !this.isResponseCacheable(response)) {
-      logger.debug("[SDK Html-cache] put skipped, non-cacheable", {
-        trace
-      });
-      return;
-    }
-    try {
-      const cache = await caches.open(CACHE_NAME + this.epoch);
-      const cacheKey = this.buildCacheKey(request);
-      await cache.delete(cacheKey);
-      const ttl = this.getTTLForRequest(request);
-      const swr = this.getSWRForRequest(request);
-      const headers = new Headers(response.headers);
-      const existingCacheControl = response.headers.get("Cache-Control");
-      if (!existingCacheControl || existingCacheControl === "public") {
-        const internalMaxAge = ttl + swr;
-        headers.set("Cache-Control", `public, max-age=${internalMaxAge}`);
-      }
-      const cacheTime = (/* @__PURE__ */ new Date()).toISOString();
-      headers.set("X-Cache-Time", cacheTime);
-      headers.set("X-Original-TTL", ttl.toString());
-      headers.set("X-Original-SWR", swr.toString());
-      if (!headers.get("Last-Modified")) {
-        headers.set("Last-Modified", new Date(cacheTime).toUTCString());
-      }
-      const cacheableResponse = new Response(response.body, {
-        status: response.status,
-        statusText: response.statusText,
-        headers
-      });
-      await cache.put(cacheKey, cacheableResponse);
-      logger.debug("[SDK Html-cache] put done", { trace });
-    } catch (_) {
-      logger.warn("[SDK Html-cache] no put support", { trace });
-    }
-  }
-  buildClientResponse(cachedResponse, ttl, swr, isStale, age) {
-    const headers = new Headers(cachedResponse.headers);
-    headers.set(
-      "Cache-Control",
-      `public, max-age=${ttl}, stale-while-revalidate=${swr}`
-    );
-    headers.set(
-      "Cloudflare-CDN-Cache-Control",
-      `public, s-maxage=${ttl}, stale-while-revalidate=${swr}, stale-if-error=60`
-    );
-    const cacheTime = headers.get("X-Cache-Time");
-    if (cacheTime) {
-      const lastModified = new Date(cacheTime).toUTCString();
-      headers.set("Last-Modified", lastModified);
-    }
-    headers.set("X-Cache-Status", isStale ? "STALE" : "HIT");
-    headers.set("X-Cache-Age", Math.floor(age).toString());
-    headers.delete("X-Original-TTL");
-    headers.delete("X-Original-SWR");
-    headers.delete("X-Cache-Time");
-    return new Response(cachedResponse.body, {
-      status: cachedResponse.status,
-      statusText: cachedResponse.statusText,
-      headers
-    });
-  }
-  buildCacheKey(request) {
-    const url = new URL(request.url);
-    const versionHash = this.generateVersionHash(request.headers);
-    const normalizedQuery = this.normalizeSearchParams(url.searchParams);
-    const cacheKeyPath = `${versionHash}${url.pathname}`;
-    const keyUrl = new URL(`${CACHE_KEY_ORIGIN}${cacheKeyPath}`);
-    if (normalizedQuery) {
-      keyUrl.search = `?${normalizedQuery}`;
-    }
-    const sanitizedHeaders = this.sanitizeHeaders(request.headers);
-    return new Request(keyUrl.toString(), {
-      method: "GET",
-      headers: sanitizedHeaders
-    });
-  }
-  sanitizeHeaders(originalHeaders) {
-    const CACHE_RELEVANT_HEADERS = [
-      // Content negotiation (affects response format)
-      "accept",
-      "accept-language"
-    ];
-    const sanitized = new Headers();
-    CACHE_RELEVANT_HEADERS.forEach((header) => {
-      const value = originalHeaders.get(header);
-      if (value) {
-        sanitized.set(header, value);
-      }
-    });
-    return sanitized;
-  }
-  generateVersionHash(headers) {
-    const swellData = this.extractSwellData(headers);
-    const versionFactors = {
-      store: headers.get("swell-storefront-id") || "",
-      auth: headers.get("swell-access-token") || "",
-      theme: headers.get("swell-theme-version-hash") || "",
-      modified: headers.get("swell-cache-modified") || "",
-      currency: swellData["swell-currency"] || "USD",
-      locale: headers.get("x-locale") || headers.get("accept-language")?.split(",")[0] || "default",
-      context: headers.get("swell-storefront-context"),
-      epoch: this.epoch
-    };
-    return md5(JSON.stringify(versionFactors));
-  }
-  extractSwellData(headers) {
-    const cookie = headers.get("cookie");
-    if (!cookie) return {};
-    const swellDataMatch = cookie.match(/swell-data=([^;]+)/);
-    if (!swellDataMatch) return {};
-    try {
-      const parsed = JSON.parse(decodeURIComponent(swellDataMatch[1]));
-      if (typeof parsed === "object" && parsed !== null) {
-        return parsed;
-      }
-      return {};
-    } catch {
-      return {};
-    }
-  }
-  isCacheable(request) {
-    const url = new URL(request.url);
-    const headers = request.headers;
-    if (headers.get("swell-deployment-mode") === "editor") {
-      return false;
-    }
-    const skipPaths = ["/checkout"];
-    if (skipPaths.some((path) => url.pathname.startsWith(path))) {
-      return false;
-    }
-    if (headers.get("cache-control")?.includes("no-cache")) {
-      return false;
-    }
-    return true;
-  }
-  isResponseCacheable(response) {
-    const contentType = response.headers.get("content-type");
-    if (!contentType?.includes("text/html")) {
-      return false;
-    }
-    if (response.headers.get("set-cookie")) {
-      return false;
-    }
-    const cacheControl = response.headers.get("cache-control");
-    if (cacheControl?.includes("no-store") || cacheControl?.includes("private")) {
-      return false;
-    }
-    return true;
-  }
-  getDeploymentMode(headers) {
-    const mode = headers.get("swell-deployment-mode");
-    if (mode === "preview" || mode === "editor") {
-      return mode;
-    }
-    return "live";
-  }
-  getTTLForRequest(request) {
-    const url = new URL(request.url);
-    const path = url.pathname;
-    const mode = this.getDeploymentMode(request.headers);
-    if (mode === "editor") {
-      return 0;
-    }
-    const config = mode === "preview" ? TTL_CONFIG.PREVIEW : TTL_CONFIG.LIVE;
-    if (path === "/") {
-      return config.HOME;
-    }
-    if (path.startsWith("/products/")) {
-      return config.PRODUCT;
-    }
-    if (path.startsWith("/categories/")) {
-      return config.COLLECTION;
-    }
-    if (path.startsWith("/pages/")) {
-      return config.PAGE;
-    }
-    if (path.startsWith("/blogs/")) {
-      return config.BLOG;
-    }
-    return config.DEFAULT;
-  }
-  getSWRForRequest(request) {
-    const mode = this.getDeploymentMode(request.headers);
-    if (mode === "editor") {
-      return 0;
-    }
-    return mode === "preview" ? TTL_CONFIG.PREVIEW.SWR : TTL_CONFIG.LIVE.SWR;
-  }
-  getResponseAge(response) {
-    const cacheTime = response.headers.get("X-Cache-Time");
-    if (!cacheTime) {
-      return Infinity;
-    }
-    const cacheDate = new Date(cacheTime);
-    if (isNaN(cacheDate.getTime())) {
-      return Infinity;
-    }
-    const age = (Date.now() - cacheDate.getTime()) / 1e3;
-    return Math.max(0, age);
-  }
-  normalizeSearchParams(searchParams) {
-    const ignoredParams = [
-      "utm_source",
-      "utm_medium",
-      "utm_campaign",
-      "utm_content",
-      "utm_term",
-      "fbclid",
-      "gclid",
-      "gbraid",
-      "wbraid",
-      "ref",
-      "source",
-      "mc_cid",
-      "mc_eid"
-    ];
-    const relevantParams = [];
-    searchParams.forEach((value, key) => {
-      if (!ignoredParams.includes(key)) {
-        relevantParams.push(
-          `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
-        );
-      }
-    });
-    return relevantParams.sort().join("&");
-  }
-};
-
 // src/resources/addresses.ts
 var SwellAddresses = class extends SwellStorefrontCollection {
   constructor(swell, query) {
@@ -16262,7 +15874,7 @@ function ShopifyAddress(instance, address, account) {
 function joinAddressLines(...props) {
   return props.filter(Boolean).join("\n");
 }
-function ShopifyCountry(_instance, countryCode) {
+function ShopifyCountry(_instance2, countryCode) {
   const currencyCode = getCurrencyByCountry(countryCode) || "USD";
   return new ShopifyResource(
     {
@@ -16595,7 +16207,7 @@ async function resolveLastOrder(instance, account) {
 }
 
 // src/compatibility/shopify-objects/font.ts
-function ShopifyFont(_instance, font) {
+function ShopifyFont(_instance2, font) {
   if (font instanceof ShopifyResource) {
     return font.clone();
   }
@@ -16606,7 +16218,7 @@ function ShopifyFont(_instance, font) {
     family: font.family,
     style: font.style,
     "system?": font.system,
-    variants: font.variants.map((variant) => ShopifyFont(_instance, variant)),
+    variants: font.variants.map((variant) => ShopifyFont(_instance2, variant)),
     weight: font.weight
   });
 }
@@ -16619,7 +16231,7 @@ var SHOPIFY_FORMS = {
     })
   }
 };
-function ShopifyForm(_instance, form) {
+function ShopifyForm(_instance2, form) {
   if (form instanceof ShopifyResource) {
     return form.clone();
   }
@@ -16916,7 +16528,7 @@ function ShopifyRecommendations(instance, product) {
 }
 
 // src/compatibility/shopify-objects/page.ts
-function ShopifyPage(_instance, page) {
+function ShopifyPage(_instance2, page) {
   if (page instanceof ShopifyResource) {
     return page.clone();
   }
@@ -18128,7 +17740,7 @@ ${injects.join("\n")}</script>`;
 };
 
 // src/compatibility/shopify-objects/template.ts
-function ShopifyTemplate(_instance, template) {
+function ShopifyTemplate(_instance2, template) {
   return new ShopifyResource(
     {
       directory: template.path,
@@ -20448,7 +20060,7 @@ var ThemeLoader = class _ThemeLoader {
       flavor,
       trace
     });
-    const storage = new ThemeFileStorage(this.swell.workerEnv, flavor);
+    const storage = new ThemeFileCache(this.swell.workerEnv, flavor);
     const result = await storage.putFiles(configs);
     if (result.warnings.length > 0) {
       logger.warn("[ThemeLoader] Theme cache updated with warnings", {
@@ -20486,7 +20098,7 @@ var ThemeLoader = class _ThemeLoader {
       total: configMetadata.length
     });
     const flavor = getKVFlavor(this.swell.workerEnv);
-    const storage = new ThemeFileStorage(this.swell.workerEnv, flavor);
+    const storage = new ThemeFileCache(this.swell.workerEnv, flavor);
     const kvHydrated = await storage.getFiles(configMetadata);
     const completeConfigs = await this.ensureConfigsHaveData(kvHydrated);
     for (const config of completeConfigs) {
@@ -21068,12 +20680,7 @@ var SwellTheme3 = class {
         // Default value (always StorefrontResource)
         () => this.fetchCart()
       ),
-      this.fetchSingletonResourceCached(
-        "account",
-        () => this.fetchAccount(),
-        () => null,
-        false
-      )
+      this.fetchAccount()
     ]);
     if (!cart) {
       throw new Error("Failed to fetch cart");
@@ -22708,6 +22315,551 @@ function getResourceQuery(slug, query) {
     ...query
   };
 }
+
+// src/cache/html-cache/html-cache.ts
+var CACHE_KEY_ORIGIN = "https://cache.swell.store";
+var DEFAULT_CACHE_RULES = {
+  defaults: {
+    live: { ttl: 20, swr: 60 * 60 * 24 * 7 },
+    // 20s TTL, 1 week SWR
+    preview: { ttl: 10, swr: 60 * 60 * 24 * 7 }
+    // 10s TTL, 1 week SWR
+  },
+  pathRules: [
+    { path: "/checkout/*", skip: true }
+  ]
+};
+var HtmlCache = class {
+  epoch;
+  backend;
+  cacheRules;
+  constructor(epoch, backend, cacheRules = DEFAULT_CACHE_RULES) {
+    this.epoch = epoch;
+    this.backend = backend;
+    this.cacheRules = cacheRules;
+  }
+  async get(request) {
+    const trace = createTraceId();
+    if (!this.canReadFromCache(request)) {
+      logger.debug("[SDK Html-cache] non-cacheable request", { trace });
+      return { found: false, cacheable: false };
+    }
+    try {
+      const cacheKey = this.buildCacheKey(request);
+      const entry = await this.backend.read(cacheKey);
+      if (!entry) {
+        logger.debug("[SDK Html-cache] cacheable, MISS", { trace });
+        return { found: false, cacheable: true };
+      }
+      const age = this.getEntryAge(entry);
+      const { ttl, swr } = entry;
+      const isStale = age >= ttl;
+      const isExpired = age >= ttl + swr;
+      if (!isExpired) {
+        logger.debug("[SDK Html-cache] cacheable, HIT", {
+          stale: isStale,
+          age,
+          trace
+        });
+        const clientResponse = this.buildClientResponse(entry, isStale, age);
+        return {
+          found: true,
+          stale: isStale,
+          response: clientResponse,
+          cacheable: true,
+          age: Math.floor(age)
+        };
+      }
+      logger.debug("[SDK Html-cache] cacheable, hit, expired", { trace });
+      return { found: false, cacheable: true };
+    } catch (e) {
+      logger.warn("[SDK Html-cache] get failed", {
+        trace,
+        error: e instanceof Error ? e.message : String(e)
+      });
+      return null;
+    }
+  }
+  async getWithConditionals(request) {
+    const result = await this.get(request);
+    if (!result?.found || result.stale) {
+      return result;
+    }
+    const ifModifiedSince = request.headers.get("If-Modified-Since");
+    const ifNoneMatch = request.headers.get("If-None-Match");
+    if ((ifModifiedSince || ifNoneMatch) && result.response) {
+      const lastModified = result.response.headers.get("Last-Modified");
+      const etag = result.response.headers.get("ETag");
+      if (this.checkNotModified(ifModifiedSince, ifNoneMatch, lastModified, etag)) {
+        result.notModified = true;
+        result.conditional304 = new Response(null, {
+          status: 304,
+          headers: {
+            "Last-Modified": lastModified || "",
+            ETag: etag || "",
+            "Cache-Control": result.response.headers.get("Cache-Control") || "",
+            "Cloudflare-CDN-Cache-Control": result.response.headers.get("Cloudflare-CDN-Cache-Control") || "",
+            "X-Cache-Status": "HIT-304"
+          }
+        });
+      }
+    }
+    return result;
+  }
+  async put(request, response) {
+    const trace = createTraceId();
+    if (!this.canWriteToCache(request, response)) {
+      logger.debug("[SDK Html-cache] put skipped, non-cacheable", { trace });
+      return;
+    }
+    try {
+      const cacheKey = this.buildCacheKey(request);
+      const ttl = this.getTTLForRequest(request);
+      const swr = this.getSWRForRequest(request);
+      const body = await response.text();
+      const cacheTimeISO = (/* @__PURE__ */ new Date()).toISOString();
+      const headers = this.normalizeHeaders(response.headers);
+      const entry = {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+        body,
+        cacheTimeISO,
+        ttl,
+        swr,
+        etag: this.quoteETag(headers["etag"] || md5(body)),
+        lastModifiedUTC: headers["last-modified"] || new Date(cacheTimeISO).toUTCString()
+      };
+      const hardExpireSeconds = ttl + swr;
+      await this.backend.write(cacheKey, entry, hardExpireSeconds);
+      logger.debug("[SDK Html-cache] put done", { trace });
+    } catch (e) {
+      logger.warn("[SDK Html-cache] put failed", {
+        trace,
+        error: e instanceof Error ? e.message : String(e)
+      });
+    }
+  }
+  async delete(requestOrKey) {
+    try {
+      const key = typeof requestOrKey === "string" ? requestOrKey : this.buildCacheKey(requestOrKey);
+      if (this.backend.delete) {
+        await this.backend.delete(key);
+      }
+    } catch (e) {
+      logger.warn("[SDK Html-cache] delete failed", {
+        error: e instanceof Error ? e.message : String(e)
+      });
+    }
+  }
+  canReadFromCache(request) {
+    const method = request.method.toUpperCase();
+    return (method === "GET" || method === "HEAD") && this.isRequestCacheable(request);
+  }
+  canWriteToCache(request, response) {
+    const method = request.method.toUpperCase();
+    return method === "GET" && response.ok && this.isRequestCacheable(request) && this.isResponseCacheable(response);
+  }
+  createRevalidationRequest(request) {
+    const headers = new Headers(request.headers);
+    headers.set("X-Cache-Bypass", "revalidation");
+    headers.delete("If-None-Match");
+    headers.delete("If-Modified-Since");
+    headers.delete("Cache-Control");
+    headers.delete("Pragma");
+    return new Request(request.url, {
+      method: "GET",
+      headers
+    });
+  }
+  buildClientResponse(entry, isStale, age) {
+    const headers = new Headers(entry.headers);
+    headers.set("Cache-Control", "public, max-age=0, must-revalidate");
+    headers.set(
+      "Cloudflare-CDN-Cache-Control",
+      `public, s-maxage=${entry.ttl}, stale-while-revalidate=${entry.swr}, stale-if-error=60`
+    );
+    if (entry.lastModifiedUTC) {
+      headers.set("Last-Modified", entry.lastModifiedUTC);
+    }
+    if (entry.etag) {
+      headers.set("ETag", entry.etag);
+    }
+    headers.set("X-Cache-Status", isStale ? "STALE" : "HIT");
+    headers.set("X-Cache-Age", Math.floor(age).toString());
+    this.sanitizeClientHeaders(headers);
+    return new Response(entry.body, {
+      status: entry.status,
+      statusText: entry.statusText,
+      headers
+    });
+  }
+  buildCacheKey(request) {
+    const url = new URL(request.url);
+    const versionHash = this.generateVersionHash(request.headers);
+    const normalizedQuery = this.normalizeSearchParams(url.searchParams);
+    const cacheKeyPath = `${versionHash}${url.pathname}`;
+    const keyUrl = new URL(`${CACHE_KEY_ORIGIN}${cacheKeyPath}`);
+    if (normalizedQuery) {
+      keyUrl.search = `?${normalizedQuery}`;
+    }
+    return keyUrl.toString();
+  }
+  checkNotModified(ifModifiedSince, ifNoneMatch, lastModified, etag) {
+    if (this.ifNoneMatchMatches(ifNoneMatch, etag)) {
+      return true;
+    }
+    if (ifModifiedSince && lastModified) {
+      try {
+        const ifModDate = new Date(ifModifiedSince);
+        const lastModDate = new Date(lastModified);
+        if (isNaN(ifModDate.getTime()) || isNaN(lastModDate.getTime())) {
+          return false;
+        }
+        return ifModDate >= lastModDate;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  ifNoneMatchMatches(ifNoneMatch, etag) {
+    if (!ifNoneMatch || !etag) return false;
+    const header = ifNoneMatch.trim();
+    if (header === "*") return true;
+    const tokens = header.split(",").map((t) => t.trim());
+    const normalizedEtag = etag.replace(/^W\//, "");
+    for (const token of tokens) {
+      if (token === etag) return true;
+      const normalizedToken = token.replace(/^W\//, "");
+      if (normalizedToken === normalizedEtag) return true;
+    }
+    return false;
+  }
+  quoteETag(value) {
+    if (!value) return value;
+    if (value.startsWith('"') || value.startsWith('W/"')) return value;
+    if (value.startsWith("W/")) return `W/"${value.slice(2)}"`;
+    return `"${value}"`;
+  }
+  sanitizeClientHeaders(headers) {
+    const HOP_BY_HOP = [
+      "connection",
+      "proxy-connection",
+      "keep-alive",
+      "transfer-encoding",
+      "upgrade",
+      "proxy-authenticate",
+      "proxy-authorization",
+      "te",
+      "trailers",
+      "via",
+      "alt-svc",
+      "content-length"
+    ];
+    for (const h of HOP_BY_HOP) headers.delete(h);
+    headers.delete("content-encoding");
+    headers.delete("x-original-ttl");
+    headers.delete("x-original-swr");
+    headers.delete("x-cache-time");
+  }
+  generateVersionHash(headers) {
+    const swellData = this.extractSwellData(headers);
+    const acceptLang = headers.get("accept-language") || "";
+    const accept = headers.get("accept") || "";
+    const versionFactors = {
+      store: headers.get("swell-storefront-id") || "",
+      app: (headers.get("swell-app-id") || "") + "@" + (swellData["swell-app-version"] || ""),
+      auth: headers.get("swell-access-token") || "",
+      theme: headers.get("swell-theme-version-hash") || "",
+      modified: headers.get("swell-cache-modified") || "",
+      currency: swellData["swell-currency"] || "USD",
+      locale: headers.get("x-locale") || acceptLang.split(",")[0].trim().toLowerCase() || "default",
+      context: headers.get("swell-storefront-context"),
+      accept,
+      epoch: this.epoch
+    };
+    return md5(JSON.stringify(versionFactors));
+  }
+  extractSwellData(headers) {
+    const cookie = headers.get("cookie");
+    if (!cookie) return {};
+    const swellDataMatch = cookie.match(/swell-data=([^;]+)/);
+    if (!swellDataMatch) return {};
+    try {
+      return JSON.parse(decodeURIComponent(swellDataMatch[1])) || {};
+    } catch {
+      return {};
+    }
+  }
+  isRequestCacheable(request) {
+    const url = new URL(request.url);
+    if (request.headers.get("swell-deployment-mode") === "editor") return false;
+    if (this.cacheRules.pathRules) {
+      for (const rule of this.cacheRules.pathRules) {
+        if (this.pathMatches(rule.path, url.pathname) && rule.skip) {
+          return false;
+        }
+      }
+    }
+    if (request.headers.get("cache-control")?.includes("no-cache"))
+      return false;
+    return true;
+  }
+  isResponseCacheable(response) {
+    if (!response.headers.get("content-type")?.includes("text/html"))
+      return false;
+    if (response.headers.get("set-cookie")) return false;
+    const cacheControl = response.headers.get("cache-control");
+    if (cacheControl?.includes("no-store") || cacheControl?.includes("private"))
+      return false;
+    return true;
+  }
+  getDeploymentMode(headers) {
+    const mode = headers.get("swell-deployment-mode");
+    return mode === "preview" ? "preview" : "live";
+  }
+  getTTLForRequest(request) {
+    const url = new URL(request.url);
+    const mode = this.getDeploymentMode(request.headers);
+    if (this.cacheRules.pathRules) {
+      for (const rule of this.cacheRules.pathRules) {
+        if (this.pathMatches(rule.path, url.pathname) && rule.ttl !== void 0) {
+          return rule.ttl;
+        }
+      }
+    }
+    const defaults = this.cacheRules.defaults?.[mode];
+    return defaults?.ttl ?? DEFAULT_CACHE_RULES.defaults[mode].ttl;
+  }
+  getSWRForRequest(request) {
+    const url = new URL(request.url);
+    const mode = this.getDeploymentMode(request.headers);
+    if (this.cacheRules.pathRules) {
+      for (const rule of this.cacheRules.pathRules) {
+        if (this.pathMatches(rule.path, url.pathname) && rule.swr !== void 0) {
+          return rule.swr;
+        }
+      }
+    }
+    const defaults = this.cacheRules.defaults?.[mode];
+    return defaults?.swr ?? DEFAULT_CACHE_RULES.defaults[mode].swr;
+  }
+  getEntryAge(entry) {
+    const t = Date.parse(entry.cacheTimeISO);
+    if (Number.isNaN(t)) return Infinity;
+    const age = (Date.now() - t) / 1e3;
+    return age < 0 ? 0 : age;
+  }
+  /**
+   * Converts wildcard pattern to regex and tests against path.
+   * - * matches any characters except /
+   * - ** matches any characters including /
+   */
+  pathMatches(pattern, path) {
+    const regex = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "___DOUBLE_STAR___").replace(/\*/g, "[^/]*").replace(/___DOUBLE_STAR___/g, ".*");
+    return new RegExp(`^${regex}$`).test(path);
+  }
+  normalizeHeaders(headers) {
+    const normalized = {};
+    headers.forEach((value, key) => {
+      normalized[key.toLowerCase()] = value;
+    });
+    return normalized;
+  }
+  normalizeSearchParams(searchParams) {
+    const ignoredParams = [
+      "utm_source",
+      "utm_medium",
+      "utm_campaign",
+      "utm_content",
+      "utm_term",
+      "fbclid",
+      "gclid",
+      "gbraid",
+      "wbraid",
+      "ref",
+      "source",
+      "mc_cid",
+      "mc_eid"
+    ];
+    const relevantParams = [];
+    searchParams.forEach((value, key) => {
+      if (!ignoredParams.includes(key)) {
+        relevantParams.push(
+          `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+        );
+      }
+    });
+    return relevantParams.sort().join("&");
+  }
+};
+
+// src/cache/html-cache/html-cache-kv.ts
+var KVCacheBackend = class {
+  kv;
+  prefix;
+  hashKeys;
+  maxValueBytes;
+  constructor(kv, opts = {}) {
+    this.kv = kv;
+    this.prefix = opts.prefix;
+    this.hashKeys = opts.hashKeys !== false;
+    this.maxValueBytes = opts.maxValueBytes ?? Math.floor(24.5 * 1024 * 1024);
+  }
+  async read(key) {
+    const kvKey = this.makeKey(key);
+    const value = await this.kv.get(kvKey, "json");
+    if (!value) return null;
+    const entry = {
+      status: value.status,
+      statusText: value.statusText,
+      headers: value.headers,
+      body: value.body,
+      cacheTimeISO: value.cacheTimeISO,
+      ttl: value.ttl,
+      swr: value.swr,
+      etag: value.etag,
+      lastModifiedUTC: value.lastModifiedUTC
+    };
+    return entry;
+  }
+  async write(key, entry, hardExpireSeconds) {
+    const kvKey = this.makeKey(key);
+    const payload = {
+      v: 1,
+      status: entry.status,
+      statusText: entry.statusText,
+      headers: entry.headers,
+      body: entry.body,
+      cacheTimeISO: entry.cacheTimeISO,
+      ttl: entry.ttl,
+      swr: entry.swr,
+      etag: entry.etag,
+      lastModifiedUTC: entry.lastModifiedUTC
+    };
+    const json = JSON.stringify(payload);
+    this.assertSize(json);
+    const metadata = {
+      v: 1,
+      cacheTimeISO: entry.cacheTimeISO,
+      ttl: entry.ttl,
+      swr: entry.swr,
+      etag: entry.etag,
+      lastModifiedUTC: entry.lastModifiedUTC
+    };
+    await this.kv.put(kvKey, json, {
+      expirationTtl: hardExpireSeconds + 60,
+      // natural hard expiry after SWR + grace period
+      metadata
+    });
+  }
+  async delete(key) {
+    const kvKey = this.makeKey(key);
+    await this.kv.delete(kvKey);
+  }
+  // ---- private helpers ----
+  makeKey(raw) {
+    const core = this.hashKeys ? md5(raw) : raw;
+    return this.prefix ? `${this.prefix}:${core}` : core;
+  }
+  assertSize(json) {
+    const bytes = typeof TextEncoder !== "undefined" ? new TextEncoder().encode(json).length : this.approxUtf8Bytes(json);
+    if (bytes > this.maxValueBytes) {
+      throw new Error(
+        `KV value too large: ${bytes} bytes exceeds limit ${this.maxValueBytes} bytes`
+      );
+    }
+  }
+  approxUtf8Bytes(str) {
+    let count = 0;
+    for (let i = 0; i < str.length; i++) {
+      const code = str.charCodeAt(i);
+      if (code <= 127) count += 1;
+      else if (code <= 2047) count += 2;
+      else count += 3;
+    }
+    return count;
+  }
+};
+
+// src/cache/html-cache/html-cache-worker.ts
+var CACHE_NAME_PREFIX = "swell-html-v0";
+var WorkerCacheBackend = class {
+  cacheName;
+  constructor(epoch) {
+    this.cacheName = CACHE_NAME_PREFIX + epoch;
+  }
+  async read(key) {
+    const cache = await caches.open(this.cacheName);
+    const request = new Request(key);
+    const response = await cache.match(request);
+    if (!response) return null;
+    const headers = {};
+    response.headers.forEach((value, name) => {
+      headers[name.toLowerCase()] = value;
+    });
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+      body: await response.text(),
+      cacheTimeISO: response.headers.get("x-cache-time") || (/* @__PURE__ */ new Date(0)).toISOString(),
+      ttl: parseInt(response.headers.get("x-original-ttl") || "0", 10),
+      swr: parseInt(response.headers.get("x-original-swr") || "0", 10),
+      etag: response.headers.get("etag") || void 0,
+      lastModifiedUTC: response.headers.get("last-modified") || void 0
+    };
+  }
+  async write(key, entry, _hardExpireSeconds) {
+    const cache = await caches.open(this.cacheName);
+    const request = new Request(key);
+    const headers = new Headers(entry.headers);
+    if (entry.lastModifiedUTC && !headers.get("Last-Modified")) {
+      headers.set("Last-Modified", entry.lastModifiedUTC);
+    }
+    if (entry.etag && !headers.get("ETag")) {
+      headers.set("ETag", entry.etag);
+    }
+    headers.set("X-Cache-Time", entry.cacheTimeISO);
+    headers.set("X-Original-TTL", String(entry.ttl));
+    headers.set("X-Original-SWR", String(entry.swr));
+    headers.delete("content-encoding");
+    headers.delete("content-length");
+    const existing = headers.get("Cache-Control");
+    if (!existing || existing.trim().toLowerCase() === "public") {
+      headers.set("Cache-Control", `public, max-age=${entry.ttl + entry.swr}`);
+    }
+    const response = new Response(entry.body, {
+      status: entry.status,
+      statusText: entry.statusText,
+      headers
+    });
+    await cache.delete(request);
+    await cache.put(request, response);
+  }
+  async delete(key) {
+    const cache = await caches.open(this.cacheName);
+    const request = new Request(key);
+    await cache.delete(request);
+  }
+};
+
+// src/cache/html-cache/html-cache-factory.ts
+var _instance = null;
+function getHtmlCache(env, cacheRules) {
+  const epoch = env?.HTML_CACHE_EPOCH;
+  if (typeof epoch !== "string" || !epoch) return null;
+  if (_instance) return _instance;
+  const kv = env?.NAMESPACE;
+  const rules = cacheRules || env?.HTML_CACHE_RULES;
+  if (env?.HTML_CACHE_BACKEND !== "worker" && kv) {
+    _instance = new HtmlCache(epoch, new KVCacheBackend(kv), rules);
+    return _instance;
+  }
+  _instance = new HtmlCache(epoch, new WorkerCacheBackend(epoch), rules);
+  return _instance;
+}
 export {
   AccountAddressesResource,
   AccountOrderResource,
@@ -22721,10 +22873,12 @@ export {
   CartResource,
   CategoriesResource,
   CategoryResource,
+  DEFAULT_CACHE_RULES,
   DEFAULT_QUERY_PAGE_LIMIT,
   DeferredShopifyResource,
   FILE_DATA_INCLUDE_QUERY,
   GEO_DATA,
+  HtmlCache,
   LANG_TO_COUNTRY_CODES,
   LiquidSwell30 as LiquidSwell,
   MAX_QUERY_PAGE_LIMIT,
@@ -22772,7 +22926,6 @@ export {
   ThemeForm,
   ThemeFormErrors,
   VariantResource,
-  WorkerHtmlCache,
   adaptShopifyFontData,
   adaptShopifyFormData,
   adaptShopifyMenuData,
@@ -22800,6 +22953,7 @@ export {
   getEasyblocksComponentDefinitions,
   getEasyblocksPagePropsWithConfigs,
   getEasyblocksPageTemplate,
+  getHtmlCache,
   getKVFlavor,
   getLayoutSectionGroups,
   getMenuItemStorefrontUrl,