@swell/apps-sdk 1.0.149 → 1.0.151

package/dist/index.mjs

@@ -626,18 +626,12 @@ var StorefrontResource = class {
     }
     return instance[prop];
   }
-  // add additional properties to the loaded result
-  _transformResult(result) {
-    return result;
-  }
   async _get(..._args) {
     if (this._getter) {
       const getter = this._getter.bind(
         this
       );
       return Promise.resolve().then(getter).then((result) => {
-        return this._transformResult(result);
-      }).then((result) => {
         this._result = result ?? null;
         if (result) {
           Object.assign(this, result);
@@ -720,7 +714,6 @@ function cloneStorefrontResource(input) {
   });
   const clone = new ClonedClass(input._getter);
   clone._params = input._params;
-  clone._transformResult = input._transformResult.bind(clone);
   Object.defineProperty(clone, "_resourceName", {
     value: resourceName
   });
@@ -774,7 +767,11 @@ var SwellStorefrontCollection = class _SwellStorefrontCollection extends SwellSt
   limit = DEFAULT_QUERY_PAGE_LIMIT;
   name;
   constructor(swell, collection, query = {}, getter) {
-    super(swell, collection, getter);
+    super(
+      swell,
+      collection,
+      getter
+    );
     this._query = this._initQuery(query);
     if (!getter) {
       this._setGetter(this._defaultGetter());
@@ -950,8 +947,6 @@ var SwellStorefrontRecord = class extends SwellStorefrontResource {
         getter,
         isResourceCacheble(this._collection)
       ).then((result) => {
-        return this._transformResult(result);
-      }).then((result) => {
         this._result = result;
         if (result) {
           Object.assign(this, result);
@@ -6697,6 +6692,50 @@ function md5(inputString) {
   return rh(a) + rh(b) + rh(c) + rh(d);
 }
 
+// src/utils/kv-flavor.ts
+var cachedKVFlavor;
+function getKVFlavor(workerEnv) {
+  if (cachedKVFlavor) {
+    return cachedKVFlavor;
+  }
+  if (!workerEnv?.THEME) {
+    cachedKVFlavor = "memory";
+    return cachedKVFlavor;
+  }
+  const kvFlavor = workerEnv.KV_FLAVOR;
+  if (kvFlavor) {
+    const flavorLower = String(kvFlavor).toLowerCase();
+    switch (flavorLower) {
+      case "cloudflare":
+      case "cf":
+        cachedKVFlavor = "cf";
+        break;
+      case "miniflare":
+        cachedKVFlavor = "miniflare";
+        break;
+      case "memory":
+        cachedKVFlavor = "memory";
+        break;
+      default:
+        logger.warn(`[KV] Unknown KV_FLAVOR: ${kvFlavor}, using miniflare`);
+        cachedKVFlavor = "miniflare";
+    }
+    return cachedKVFlavor;
+  }
+  try {
+    if (typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers") {
+      cachedKVFlavor = "cf";
+      return cachedKVFlavor;
+    }
+  } catch {
+  }
+  cachedKVFlavor = "miniflare";
+  return cachedKVFlavor;
+}
+function resetKVFlavorCache() {
+  cachedKVFlavor = void 0;
+}
+
 // src/utils/index.ts
 function isSectionConfig(config, themeConfigs) {
   if (!config.file_path.startsWith("theme/sections/")) {
@@ -7226,68 +7265,584 @@ function buildStores2() {
 
 // src/cache/theme-cache.ts
 var TTL = 90 * 24 * 60 * 60 * 1e3;
-var ThemeCache = class extends Cache {
-  constructor(options) {
-    super({
-      ttl: TTL,
-      ...options
+
+// 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;
+  }
+  async get(keys) {
+    if (keys.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const result = await this.kv.get(keys, "text");
+    if (!(result instanceof Map)) {
+      const map = /* @__PURE__ */ new Map();
+      for (const key of keys) {
+        map.set(key, null);
+      }
+      return map;
+    }
+    return result;
+  }
+  async put(key, value, metadata) {
+    await this.kv.put(key, value, { metadata });
+  }
+};
+var MiniflareKV = class {
+  constructor(kv) {
+    this.kv = kv;
+  }
+  async get(keys) {
+    if (keys.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const result = /* @__PURE__ */ new Map();
+    await Promise2.map(
+      keys,
+      async (key) => {
+        const value = await this.kv.get(key, "text");
+        result.set(key, value);
+      },
+      { concurrency: 50 }
+    );
+    return result;
+  }
+  async put(key, value, metadata) {
+    await this.kv.put(key, value, { metadata });
+  }
+};
+var MemoryKV = class {
+  store = /* @__PURE__ */ new Map();
+  async get(keys) {
+    const result = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      const entry = this.store.get(key);
+      result.set(key, entry?.value ?? null);
+    }
+    return result;
+  }
+  async put(key, value, metadata) {
+    this.store.set(key, { value, metadata });
+  }
+};
+function createClientKV(env, flavor = "cf") {
+  if (env?.THEME) {
+    if (flavor === "miniflare") {
+      return new MiniflareKV(env.THEME);
+    }
+    return new CFKV(env.THEME);
+  }
+  return new MemoryKV();
+}
+
+// src/cache/theme-file-storage.ts
+var { Promise: Promise3 } = bluebird2;
+var ThemeFileStorage = 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
+   */
+  buildKey(hash) {
+    return `file_data:${hash}`;
+  }
+  /**
+   * Extract hash from a KV storage key
+   */
+  extractHashFromKey(key) {
+    return key.replace("file_data:", "");
+  }
+  /**
+   * Plan GET batches based on file sizes to avoid 413 errors
+   * Uses round-robin distribution for even batch sizes
+   */
+  planGetBatches(configs) {
+    if (configs.length === 0) {
+      return [];
+    }
+    const sorted = [...configs].sort((a, b) => {
+      const sizeA = a.file?.length || 0;
+      const sizeB = b.file?.length || 0;
+      return sizeB - sizeA;
+    });
+    const totalSize = sorted.reduce((sum, config) => {
+      return sum + (config.file?.length || 0);
+    }, 0);
+    const sizeBatches = Math.ceil(totalSize / this.maxBatchSize);
+    const keyBatches = Math.ceil(sorted.length / 100);
+    const targetBatches = Math.max(sizeBatches, keyBatches);
+    const batches = Array.from(
+      { length: targetBatches },
+      () => ({
+        configs: [],
+        keys: [],
+        estimatedSize: 0
+      })
+    );
+    sorted.forEach((config, index) => {
+      const batchIndex = index % targetBatches;
+      const batch = batches[batchIndex];
+      batch.configs.push(config);
+      batch.keys.push(this.buildKey(config.hash));
+      batch.estimatedSize += config.file?.length || 0;
+    });
+    return batches.filter((batch) => batch.configs.length > 0);
+  }
+  /**
+   * Load a single batch from KV storage
+   */
+  async loadBatch(batch) {
+    return this.kv.get(batch.keys);
+  }
+  /**
+   * Merge batch results with original configs
+   */
+  mergeResults(configs, batchResults) {
+    const allData = /* @__PURE__ */ new Map();
+    for (const batchResult of batchResults) {
+      for (const [key, value] of batchResult.entries()) {
+        allData.set(key, value);
+      }
+    }
+    return configs.map((config) => {
+      const key = this.buildKey(config.hash);
+      const fileData = allData.get(key);
+      if (fileData) {
+        return {
+          ...config,
+          file_data: fileData
+        };
+      }
+      return config;
+    });
+  }
+  async getFiles(configs) {
+    if (configs.length === 0) {
+      return [];
+    }
+    const trace = createTraceId();
+    const batches = this.planGetBatches(configs);
+    const totalSize = batches.reduce((sum, b) => sum + b.estimatedSize, 0);
+    const maxBatchSize = Math.max(...batches.map((b) => b.estimatedSize));
+    logger.debug("[ThemeFileStorage] Loading files start", {
+      totalConfigs: configs.length,
+      batchCount: batches.length,
+      maxBatchSize,
+      totalSize,
+      trace
+    });
+    const results = await Promise3.map(
+      batches,
+      (batch) => this.loadBatch(batch),
+      { concurrency: Math.min(this.maxConcurrency, batches.length) }
+    );
+    const mergedConfigs = this.mergeResults(configs, results);
+    const loadedCount = mergedConfigs.filter((c) => c.file_data).length;
+    logger.debug("[ThemeFileStorage] Loading files end", {
+      requested: configs.length,
+      loaded: loadedCount,
+      missing: configs.length - loadedCount,
+      batches: batches.length,
+      trace
+    });
+    return mergedConfigs;
+  }
+  /**
+   * Validate file sizes and categorize by threshold
+   */
+  validateFiles(configs) {
+    const valid = [];
+    const warnings = [];
+    for (const config of configs) {
+      if (!config.file_data) {
+        continue;
+      }
+      const size = config.file?.length || 0;
+      if (size >= 25 * 1024 * 1024) {
+        warnings.push({
+          hash: config.hash,
+          filePath: config.file_path,
+          size,
+          reason: "exceeded_25mb",
+          action: "rejected"
+        });
+      } else if (size >= 5 * 1024 * 1024) {
+        warnings.push({
+          hash: config.hash,
+          filePath: config.file_path,
+          size,
+          reason: "rejected_5mb",
+          action: "rejected"
+        });
+      } else {
+        if (size >= 1024 * 1024) {
+          warnings.push({
+            hash: config.hash,
+            filePath: config.file_path,
+            size,
+            reason: "warning_1mb",
+            action: "stored"
+          });
+        }
+        valid.push(config);
+      }
+    }
+    return { valid, warnings };
+  }
+  /**
+   * Check which files already exist in KV storage
+   * Uses batch planning to avoid 413 errors when checking existence
+   */
+  async checkExistence(configs) {
+    if (configs.length === 0) {
+      return /* @__PURE__ */ new Set();
+    }
+    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 }
+    );
+    for (const batchResult of results) {
+      for (const [key, value] of batchResult.entries()) {
+        if (value !== null) {
+          const hash = this.extractHashFromKey(key);
+          existing.add(hash);
+        }
+      }
+    }
+    return existing;
+  }
+  async putFiles(configs) {
+    const result = {
+      written: 0,
+      skipped: 0,
+      skippedExisting: 0,
+      warnings: []
+    };
+    if (configs.length === 0) {
+      return result;
+    }
+    const trace = createTraceId();
+    logger.debug("[ThemeFileStorage] Put files start", {
+      totalConfigs: configs.length,
+      trace
+    });
+    const { valid, warnings } = this.validateFiles(configs);
+    result.warnings = warnings;
+    if (warnings.length > 0) {
+      const rejectedCount = warnings.filter(
+        (w) => w.action === "rejected"
+      ).length;
+      const warnedCount = warnings.filter((w) => w.action === "stored").length;
+      logger.warn("[ThemeFileStorage] File size validation issues", {
+        totalWarnings: warnings.length,
+        rejected: rejectedCount,
+        warned: warnedCount,
+        trace
+      });
+      warnings.filter((w) => w.action === "rejected").forEach((w) => {
+        logger.error("[ThemeFileStorage] File rejected due to size", {
+          filePath: w.filePath,
+          size: w.size,
+          reason: w.reason,
+          trace
+        });
+      });
+    }
+    const rejected = warnings.filter((w) => w.action === "rejected").length;
+    result.skipped = rejected + (configs.length - configs.filter((c) => c.file_data).length);
+    logger.debug("[ThemeFileStorage] Checking existence", {
+      validFiles: valid.length,
+      trace
+    });
+    const existing = await this.checkExistence(valid);
+    result.skippedExisting = existing.size;
+    const toWrite = valid.filter((config) => !existing.has(config.hash));
+    if (toWrite.length > 0) {
+      logger.debug("[ThemeFileStorage] Writing new files", {
+        toWrite: toWrite.length,
+        skippedExisting: existing.size,
+        trace
+      });
+      await Promise3.map(
+        toWrite,
+        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);
+          result.written++;
+        },
+        { concurrency: this.maxConcurrency }
+      );
+    }
+    logger.info("[ThemeFileStorage] Put files complete", {
+      written: result.written,
+      skipped: result.skipped,
+      skippedExisting: result.skippedExisting,
+      warnings: result.warnings.length,
+      trace
     });
+    return result;
+  }
+};
+
+// src/cache/constants.ts
+var SECOND = 1e3;
+var MINUTE = 60 * SECOND;
+var HOUR = 60 * MINUTE;
+var DAY = 24 * HOUR;
+var YEAR = 365 * DAY;
+var MAX_TTL = YEAR;
+var SHORT_TTL = 5 * SECOND;
+
+// src/cache/worker-cache-proxy.ts
+var CACHE_NAME = "swell-cache-v1";
+var CACHE_KEY_ORIGIN = "https://cache.swell.store";
+var WorkerCacheProxy = class {
+  swell;
+  constructor(swell) {
+    this.swell = swell;
+  }
+  /**
+   * Reads a JSON value from Worker Cache using a key built from path+query.
+   * Returns null on miss or if running outside of a Worker environment.
+   */
+  async get(path, query, opts) {
+    if (typeof caches === "undefined") {
+      return null;
+    }
+    const { keyUrl } = await this.buildKeyUrl(path, query, opts?.version);
+    try {
+      const cache = await caches.open(CACHE_NAME);
+      const match = await cache.match(keyUrl);
+      if (!match) return null;
+      const data = await match.json();
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Stores a JSON value in Worker Cache under key built from path+query.
+   * No-ops outside of a Worker environment.
+   */
+  async put(path, query, value, opts) {
+    if (typeof caches === "undefined") {
+      return;
+    }
+    const { keyUrl, hasVersion } = await this.buildKeyUrl(
+      path,
+      query,
+      opts?.version
+    );
+    const ttlMs = hasVersion ? MAX_TTL : SHORT_TTL;
+    try {
+      const cache = await caches.open(CACHE_NAME);
+      const response = new Response(JSON.stringify(value), {
+        headers: {
+          "Content-Type": "application/json",
+          "Cache-Control": `public, max-age=${Math.floor(ttlMs / 1e3)}`
+        }
+      });
+      await cache.put(keyUrl, response);
+    } catch {
+    }
+  }
+  /**
+   * Builds a deterministic key URL for Worker Cache from the backend API URL
+   * composed using path and query. Includes tenant and auth isolation and an
+   * optional version segment.
+   */
+  async buildKeyUrl(path, query, explicitVersion) {
+    const apiHost = this.swell.backend?.apiHost;
+    const endpointPath = String(path).startsWith("/") ? String(path).substring(1) : String(path);
+    let queryString = "";
+    if (query && this.swell.backend) {
+      queryString = this.swell.backend.stringifyQuery(query);
+    }
+    const fullUrl = `${apiHost}/${endpointPath}${queryString ? `?${queryString}` : ""}`;
+    const instanceId = this.swell.instanceId || "";
+    const authKey = String(this.swell.swellHeaders?.["swell-auth-key"] || "");
+    const tenantHash = await this.sha256Hex(`${instanceId}|${authKey}`);
+    const version = explicitVersion !== void 0 ? explicitVersion : this.swell.swellHeaders?.["theme-version-hash"] || null;
+    const hasVersion = Boolean(version);
+    const versionHash = hasVersion ? await this.sha256Hex(String(version)) : null;
+    const urlHash = await this.sha256Hex(fullUrl);
+    const keyUrl = versionHash ? `${CACHE_KEY_ORIGIN}/v1/${tenantHash}/${versionHash}/${urlHash}` : `${CACHE_KEY_ORIGIN}/v1/${tenantHash}/${urlHash}`;
+    return { keyUrl, hasVersion };
+  }
+  /**
+   * SHA-256 digest with hex encoding. Requires Worker crypto; callers
+   * should avoid invoking this outside of Worker code paths.
+   */
+  async sha256Hex(input) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.digest) {
+      const encoder = new TextEncoder();
+      const digest = await crypto.subtle.digest(
+        "SHA-256",
+        encoder.encode(input)
+      );
+      const bytes = new Uint8Array(digest);
+      return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    return md5(input);
+  }
+};
+
+// src/resources/addresses.ts
+var SwellAddresses = class extends SwellStorefrontCollection {
+  constructor(swell, query) {
+    const { page, limit: limit2 } = swell.queryParams;
+    super(swell, "accounts:addresses", { page, limit: limit2, ...query }, function() {
+      return this._swell.storefront.account.listAddresses(
+        this._query
+      );
+    });
+  }
+};
+
+// src/resources/orders.ts
+var SwellOrders = class extends SwellStorefrontCollection {
+  constructor(swell, query) {
+    const { page, limit: limit2 } = swell.queryParams;
+    super(swell, "accounts:orders", { page, limit: limit2, ...query }, function() {
+      return this._swell.storefront.account.listOrders(this._query);
+    });
+  }
+};
+
+// src/resources/subscriptions.ts
+var SwellSubscriptions = class extends SwellStorefrontCollection {
+  constructor(swell, query) {
+    const { page, limit: limit2 } = swell.queryParams;
+    super(
+      swell,
+      "accounts:subscriptions",
+      { page, limit: limit2, ...query },
+      function() {
+        return this._swell.storefront.subscriptions.list(
+          this._query
+        );
+      }
+    );
   }
 };
 
 // src/resources/account.ts
 var SwellAccount = class extends SwellStorefrontSingleton {
-  constructor(swell, getter) {
-    super(swell, "account", getter);
+  constructor(swell) {
+    super(swell, "account", async function() {
+      const account = await this._defaultGetter().call(this);
+      if (!account) {
+        return null;
+      }
+      account.addresses = new SwellAddresses(
+        this._swell
+      );
+      account.orders = new SwellOrders(
+        this._swell
+      );
+      account.subscriptions = new SwellSubscriptions(
+        this._swell
+      );
+      return account;
+    });
     return this._getProxy();
   }
 };
 
 // src/resources/blog_category.ts
 var SwellBlogCategory = class extends SwellStorefrontRecord {
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "content/blog-categories", id, query, getter);
+  constructor(swell, id, query) {
+    super(swell, "content/blog-categories", id, query, async function() {
+      const category = await this._defaultGetter().call(this);
+      if (!category) {
+        return null;
+      }
+      category.blogs = new SwellStorefrontCollection(
+        this._swell,
+        "content/blogs",
+        {
+          category_id: category.id,
+          expand: "author"
+        }
+      );
+      return category;
+    });
     return this._getProxy();
   }
 };
 
 // src/resources/blog.ts
 var SwellBlog = class extends SwellStorefrontRecord {
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "content/blogs", id, query, getter);
+  constructor(swell, blogId, categoryId, query) {
+    super(swell, "content/blogs", blogId, query, async function() {
+      this._query = { ...this._query, expand: "author" };
+      const blog = await this._defaultGetter().call(this);
+      if (!blog) {
+        return null;
+      }
+      if (categoryId) {
+        blog.category = new SwellStorefrontRecord(
+          this._swell,
+          "content/blog-categories",
+          categoryId
+        );
+      }
+      return blog;
+    });
     return this._getProxy();
   }
 };
 
 // src/resources/cart.ts
 var SwellCart = class extends SwellStorefrontSingleton {
-  constructor(swell, getter) {
-    super(swell, "cart", getter);
-    return this._getProxy();
-  }
-};
-
-// src/resources/category.ts
-var SwellCategory = class extends SwellStorefrontRecord {
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "categories", id, query, getter);
-    return this._getProxy();
-  }
-};
-
-// src/resources/order.ts
-var SwellOrder = class extends SwellStorefrontRecord {
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "orders", id, query, getter);
+  constructor(swell) {
+    super(swell, "cart");
     return this._getProxy();
   }
 };
 
-// src/resources/page.ts
-var SwellPage = class extends SwellStorefrontRecord {
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "content/pages", id, query, getter);
-    return this._getProxy();
+// src/resources/categories.ts
+var SwellCategories = class extends SwellStorefrontCollection {
+  constructor(swell, query) {
+    super(
+      swell,
+      "categories",
+      {
+        limit: 100,
+        top_id: null,
+        ...query
+      },
+      async function() {
+        const categories = await this._defaultGetter().call(this);
+        if (!categories) {
+          return null;
+        }
+        for (const category of categories.results) {
+          category.products = new SwellStorefrontCollection(
+            this._swell,
+            "products",
+            { category: category.id }
+          );
+        }
+        return categories;
+      }
+    );
   }
 };
 
@@ -7438,15 +7993,152 @@ function getSelectedSubscriptionPurchaseOptionPlan(selectedPurchaseOptionType, s
   if (selectedPurchaseOptionType !== "subscription") {
     return null;
   }
-  const { purchase_option: purchaseOption } = queryParams;
-  let selectedPlan = null;
-  if (purchaseOption?.plan_id) {
-    selectedPlan = subscriptionPurchaseOption.plans.find(
-      (plan) => plan.id === purchaseOption.plan_id
-    );
+  const { purchase_option: purchaseOption } = queryParams;
+  let selectedPlan = null;
+  if (purchaseOption?.plan_id) {
+    selectedPlan = subscriptionPurchaseOption.plans.find(
+      (plan) => plan.id === purchaseOption.plan_id
+    );
+  }
+  return selectedPlan || subscriptionPurchaseOption.plans[0];
+}
+var SORT_OPTIONS = Object.freeze([
+  { value: "", name: "Featured" },
+  { value: "popularity", name: "Popularity", query: "popularity desc" },
+  { value: "price_asc", name: "Price, low to high", query: "price asc" },
+  { value: "price_desc", name: "Price, high to low", query: "price desc" },
+  { value: "date_asc", name: "Date, old to new", query: "date asc" },
+  { value: "date_desc", name: "Date, new to old", query: "date desc" },
+  { value: "name_asc", name: "Product name, A-Z", query: "name asc" },
+  { value: "name_desc", name: "Product name, Z-A", query: "name desc" }
+]);
+async function getProductFilters(swell, productQuery) {
+  const sortBy = swell.queryParams.sort || "";
+  const filterQuery = productQueryWithFilters(swell, productQuery);
+  return {
+    filter_options: await getProductFiltersByQuery(swell, filterQuery),
+    sort: SORT_OPTIONS.find((option) => option.value === sortBy)?.value,
+    sort_options: [...SORT_OPTIONS]
+  };
+}
+async function getProductFiltersByQuery(swell, query = {}) {
+  const filters2 = await swell.get("/products/:filters", {
+    ...query,
+    sort: void 0
+  }) || [];
+  if (!Array.isArray(filters2)) {
+    throw new Error("Product filters must be an array");
+  }
+  for (const filter of filters2) {
+    filter.param_name = `filter_${filter.id}`;
+    if (Array.isArray(filter.options)) {
+      filter.active_options = [];
+      filter.inactive_options = [];
+      for (const option of filter.options) {
+        const queryValue = swell.queryParams[filter.param_name];
+        option.active = Array.isArray(queryValue) ? queryValue.includes(option.value) : queryValue === option.value;
+        const list = option.active ? filter.active_options : filter.inactive_options;
+        list.push(option);
+      }
+    }
+  }
+  return filters2;
+}
+function productQueryWithFilters(swell, query) {
+  const filters2 = Object.keys(swell.queryParams).reduce(
+    (acc, key) => {
+      if (key.startsWith("filter_")) {
+        const qkey = key.replace("filter_", "");
+        const value = swell.queryParams[key];
+        if (typeof value === "object" && value !== null && !Array.isArray(value) && (value.gte !== void 0 || value.lte !== void 0)) {
+          acc[qkey] = [value.gte || 0, value.lte || void 0];
+        } else {
+          acc[qkey] = value;
+        }
+      }
+      return acc;
+    },
+    {}
+  );
+  const sortBy = swell.queryParams.sort || "";
+  return {
+    sort: SORT_OPTIONS.find((option) => option.value === sortBy)?.query || void 0,
+    $filters: filters2,
+    ...query
+  };
+}
+
+// src/resources/category.ts
+var SwellCategory = class extends SwellStorefrontRecord {
+  constructor(swell, id, query) {
+    super(swell, "categories", id, query, async function() {
+      let category = await this._defaultGetter().call(this);
+      if (!category && this._id === "all") {
+        category = {
+          name: "Products",
+          id: "all",
+          slug: "all",
+          filter_options: [],
+          sort_options: []
+        };
+      }
+      if (!category) {
+        return null;
+      }
+      const productFilters = await getProductFilters(
+        this._swell,
+        category.id !== "all" ? { category: category.id, $variants: true } : { $variants: true }
+      );
+      Object.assign(category, productFilters);
+      return category;
+    });
+    return this._getProxy();
+  }
+};
+
+// src/resources/order.ts
+var SwellOrder = class extends SwellStorefrontRecord {
+  constructor(swell, id, query) {
+    super(swell, "accounts:orders", id, query, function() {
+      return this._swell.storefront.account.getOrder(this._id);
+    });
+    return this._getProxy();
+  }
+};
+
+// src/resources/page.ts
+var SwellPage = class extends SwellStorefrontRecord {
+  constructor(swell, id, query) {
+    super(swell, "content/pages", id, query);
+    return this._getProxy();
+  }
+};
+
+// src/resources/predictive_search.ts
+var SwellPredictiveSearch = class extends StorefrontResource {
+  constructor(swell, query) {
+    super(async function() {
+      const performed = String(query || "").length > 0;
+      let products;
+      if (performed) {
+        products = new SwellStorefrontCollection(
+          swell,
+          "products",
+          {
+            search: query,
+            limit: 10
+          }
+        );
+        await products.resolve();
+      }
+      return {
+        query,
+        performed,
+        products
+      };
+    });
   }
-  return selectedPlan || subscriptionPurchaseOption.plans[0];
-}
+};
 
 // src/resources/variant.ts
 function transformSwellVariant(params, product, variant) {
@@ -7466,27 +8158,30 @@ function transformSwellVariant(params, product, variant) {
     )
   };
 }
+var SwellVariant = class extends SwellStorefrontRecord {
+  product;
+  constructor(swell, product, id, query) {
+    super(swell, "products:variants", id, query, async function() {
+      const variant = await this._swell.get(
+        "/products:variants/{id}",
+        { id: this._id }
+      );
+      return variant ?? null;
+    });
+    this.product = product;
+  }
+};
 
 // src/resources/product.ts
-var SORT_OPTIONS = [
-  { value: "", name: "Featured" },
-  { value: "popularity", name: "Popularity", query: "popularity desc" },
-  { value: "price_asc", name: "Price, low to high", query: "price asc" },
-  { value: "price_desc", name: "Price, high to low", query: "price desc" },
-  { value: "date_asc", name: "Date, old to new", query: "date asc" },
-  { value: "date_desc", name: "Date, new to old", query: "date desc" },
-  { value: "name_asc", name: "Product name, A-Z", query: "name asc" },
-  { value: "name_desc", name: "Product name, Z-A", query: "name desc" }
-];
 function transformSwellProduct(params, product) {
   if (!product) {
-    return product;
+    return null;
   }
   const newProduct = {
     ...product,
     // add swell properties there
     selected_option_values: getSelectedVariantOptionValues(product, params),
-    purchase_options: getPurchaseOptions(product, params)
+    purchase_options: getPurchaseOptions(product, params) ?? void 0
   };
   if (Array.isArray(newProduct.variants?.results)) {
     newProduct.variants = {
@@ -7499,43 +8194,49 @@ function transformSwellProduct(params, product) {
   return newProduct;
 }
 var SwellProduct = class extends SwellStorefrontRecord {
-  _params;
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "products", id, query, getter);
-    this._params = swell.queryParams;
+  constructor(swell, id, query) {
+    const params = swell.queryParams;
+    super(swell, "products", id, query, async function() {
+      const result = await this._defaultGetter().call(this);
+      return transformSwellProduct(params, result);
+    });
     return this._getProxy();
   }
-  // add swell properties to the resolved object
-  _transformResult(result) {
-    const res = transformSwellProduct(
-      this._params,
-      result
-    );
-    return res;
+};
+
+// src/resources/product_recommendations.ts
+var SwellProductRecommendations = class extends SwellProduct {
+  constructor(swell, id, query) {
+    super(swell, id, { ...query, $recommendations: true });
+  }
+};
+
+// src/resources/search.ts
+var SwellSearch = class extends StorefrontResource {
+  constructor(swell, query) {
+    super(async () => {
+      const performed = String(query || "").length > 0;
+      const productFilters = await getProductFilters(
+        swell,
+        performed ? { search: query } : void 0
+      );
+      return {
+        query,
+        performed,
+        ...productFilters
+      };
+    });
+  }
+};
+
+// src/resources/subscription.ts
+var SwellSubscription = class extends SwellStorefrontRecord {
+  constructor(swell, id, query) {
+    super(swell, "accounts:subscriptions", id, query, function() {
+      return this._swell.storefront.subscriptions.get(this._id, this._query);
+    });
   }
 };
-function productQueryWithFilters(swell, query = {}) {
-  const sortBy = swell.queryParams.sort || "";
-  const filters2 = Object.entries(swell.queryParams).reduce(
-    (acc, [key, value]) => {
-      if (key.startsWith("filter_")) {
-        const qkey = key.replace("filter_", "");
-        if (value?.gte !== void 0 || value?.lte !== void 0) {
-          acc[qkey] = [value.gte || 0, value.lte || void 0];
-        } else {
-          acc[qkey] = value;
-        }
-      }
-      return acc;
-    },
-    {}
-  );
-  return {
-    sort: SORT_OPTIONS.find((option) => option.value === sortBy)?.query || void 0,
-    $filters: filters2,
-    ...query
-  };
-}
 
 // src/api.ts
 var DEFAULT_API_HOST = "https://api.schema.io";
@@ -7596,7 +8297,7 @@ var Swell = class _Swell {
     this.workerEnv = workerEnv;
     this.resourceLoadingIndicator = params.resourceLoadingIndicator;
     logger.info(
-      `[SDK] KV cache: ${this.workerEnv?.THEME ? "enabled" : "disabled"}`
+      `[SDK] KV cache: ${this.workerEnv?.THEME ? "enabled" : "disabled"}, flavor: ${getKVFlavor(this.workerEnv)}`
     );
     if (serverHeaders) {
       const { headers: headers2, swellHeaders: swellHeaders2 } = _Swell.formatHeaders(serverHeaders);
@@ -15106,11 +15807,9 @@ function getProducts(instance, object, mapper) {
         return this._defaultGetter().call(this);
       }
     );
-    return products._cloneWithCompatibilityResult(
-      (products2) => {
-        return { ...products2, results: products2.results.map(mapper) };
-      }
-    );
+    return products._cloneWithCompatibilityResult((products2) => {
+      return { ...products2, results: products2.results.map(mapper) };
+    });
   });
 }
 function makeProductsCollectionResolve(instance, object, mapper) {
@@ -15127,19 +15826,24 @@ function makeProductsCollectionResolve(instance, object, mapper) {
 
 // src/compatibility/shopify-objects/collections.ts
 function ShopifyCollections(instance, categories) {
-  return new SwellStorefrontCollection(instance.swell, categories._collection, categories._query, async () => {
-    const results = (await categories.results)?.map((category) => {
-      return ShopifyCollection(instance, category);
-    });
-    return {
-      page: categories.page ?? 1,
-      count: categories.count ?? 0,
-      results: results ?? [],
-      page_count: categories.page_count ?? 0,
-      limit: categories.limit,
-      pages: categories.pages ?? {}
-    };
-  });
+  return new SwellStorefrontCollection(
+    instance.swell,
+    categories._collection,
+    categories._query,
+    async () => {
+      const results = (await categories.results)?.map((category) => {
+        return ShopifyCollection(instance, category);
+      });
+      return {
+        page: categories.page ?? 1,
+        count: categories.count ?? 0,
+        results: results ?? [],
+        page_count: categories.page_count ?? 0,
+        limit: categories.limit,
+        pages: categories.pages ?? {}
+      };
+    }
+  );
 }
 
 // src/compatibility/shopify-objects/address.ts
@@ -16326,13 +17030,12 @@ var ImagesDrop = class extends Drop7 {
 var SwellImage = class extends StorefrontResource {
   constructor(swell, name) {
     super(async () => {
-      const files = await swell.get("/:files", {
+      const file = await swell.get("/:files/:last", {
         private: { $ne: true },
         content_type: { $regex: "^image/" },
         filename: name
       });
-      const file = files?.results[0] ?? null;
-      if (file === null) {
+      if (!file) {
         return null;
       }
       return { file };
@@ -19255,296 +19958,255 @@ function getLiquidFS(getThemeConfig, extName) {
 }
 
 // src/theme/theme-loader.ts
-import bluebird from "bluebird";
-var { Promise: Promise2 } = bluebird;
 var MAX_INDIVIDUAL_CONFIGS_TO_FETCH = 50;
-var ThemeLoader = class _ThemeLoader {
-  static cache = null;
+var ThemeLoader = class {
   swell;
-  manifest;
   configs;
-  configPaths;
   constructor(swell) {
     this.swell = swell;
-    this.manifest = null;
     this.configs = /* @__PURE__ */ new Map();
-    this.configPaths = [];
   }
+  /**
+   * Initialize the theme loader with all configurations.
+   * Either uses provided configs (editor mode) or loads from storage.
+   */
   async init(themeConfigs) {
     if (themeConfigs) {
       this.setConfigs(themeConfigs);
       return;
     }
     if (!this.getThemeId()) {
+      logger.debug("[ThemeLoader] No theme ID, skipping init");
       return;
     }
-    await this.fetchManifest();
-    if (this.manifest === null) {
-      console.log("ThemeLoader.init - version manifest not found");
-      await this.loadTheme();
-    }
+    await this.loadAllConfigs();
+    logger.info("[ThemeLoader] Initialization complete", {
+      configCount: this.configs.size,
+      themeId: this.getThemeId()
+    });
   }
   /**
-   * Loads theme configs for this version.
+   * Get a single config by file path (synchronous).
+   * Returns null if config not found.
    */
-  async loadTheme() {
-    const { swellHeaders } = this.swell;
-    console.log("ThemeLoader.loadTheme", swellHeaders["theme-version-hash"]);
-    if (swellHeaders["theme-version-hash"]) {
-      const configs = await this.loadThemeFromManifest();
-      if (configs) {
-        return configs;
-      }
-    }
-    return this.loadThemeAllConfigs();
+  getConfig(filePath) {
+    return this.configs.get(filePath) ?? null;
   }
   /**
-   * Returns the cache instance for this theme loader.
+   * Get all loaded configs.
+   * Used by theme getter to expose configs to editor/tests.
    */
-  getCache() {
-    if (_ThemeLoader.cache === null) {
-      _ThemeLoader.cache = new ThemeCache({
-        kvStore: this.swell.workerEnv?.THEME
-      });
-    }
-    return _ThemeLoader.cache;
+  getConfigs() {
+    return this.configs;
   }
   /**
-   * Load theme configs from internal data, typically in the editor.
+   * Get multiple configs by path pattern (synchronous).
+   * Filters configs by prefix and optional suffix.
    */
-  setConfigs(themeConfigs) {
-    this.configs = new Map(themeConfigs);
-    this.manifest = /* @__PURE__ */ new Map();
-    for (const { file_path, hash } of this.configs.values()) {
-      this.manifest.set(file_path, hash);
+  getConfigsByPath(pathPrefix, pathSuffix) {
+    const results = [];
+    for (const [path, config] of this.configs) {
+      if (path.startsWith(pathPrefix) && (!pathSuffix || path.endsWith(pathSuffix))) {
+        results.push(config);
+      }
     }
-    this.configPaths = Array.from(this.configs.keys());
+    return results;
   }
   /**
-   * Preloads a theme version and configs. This is used to optimize initial theme load.
+   * Load theme configs from internal data, typically in the editor.
+   * Used when configs are provided externally (e.g., from editor).
    */
-  async preloadTheme(payload) {
-    const { version, configs } = payload;
-    console.log(
-      `ThemeLoader.preloadTheme${version?.hash ? ` - manifest: ${version.hash}` : ""}${configs?.length ? ` - configs: ${configs.length}` : ""}`
-    );
-    const promises = [];
-    if (version) {
-      promises.push(this.cacheManifest(version));
-    }
-    if (configs) {
-      const themeId = this.getThemeId();
-      promises.push(
-        Promise2.map(
-          configs,
-          async (config) => {
-            const promises2 = [
-              this.cacheThemeConfig(config)
-            ];
-            if (themeId && config.file?.url) {
-              promises2.push(
-                this.cacheThemeFileUrl(themeId, config.hash, config.file.url)
-              );
-            }
-            await Promise2.all(promises2);
-          },
-          { concurrency: 10 }
-        )
-      );
-    }
-    await Promise2.all(promises);
+  setConfigs(themeConfigs) {
+    this.configs = new Map(themeConfigs);
   }
   /**
-   * Fetches a theme config by file path.
+   * Updates KV with file_data for provided theme configs (warmup path).
+   * Uses the new ThemeFileStorage abstraction for optimized operations.
    */
-  async fetchThemeConfig(filePath) {
-    const config = this.configs.get(filePath);
-    if (config !== void 0) {
-      return config;
-    }
-    const hash = this.manifest?.get(filePath);
-    if (!hash) {
-      return null;
+  async updateThemeCache(payload) {
+    const configs = payload?.configs || [];
+    if (configs.length === 0) {
+      logger.debug("[ThemeLoader] No configs to cache");
+      return {
+        written: 0,
+        skipped: 0,
+        skippedExisting: 0,
+        warnings: []
+      };
     }
-    const cache = this.getCache();
-    const themeId = this.getThemeId();
-    const [themeConfig, fileUrl] = await Promise2.all([
-      cache.get(`config:${hash}`),
-      themeId ? cache.get(`file:${themeId}:${hash}`) : void 0
-    ]);
-    if (themeConfig) {
-      let config2 = themeConfig;
-      if (fileUrl && themeConfig.file?.url) {
-        config2 = {
-          ...themeConfig,
-          file: { ...themeConfig.file, url: fileUrl }
-        };
-      }
-      this.configs.set(filePath, config2);
-      return config2;
+    const flavor = getKVFlavor(this.swell.workerEnv);
+    const trace = createTraceId();
+    logger.info("[ThemeLoader] Starting theme cache update", {
+      totalConfigs: configs.length,
+      flavor,
+      trace
+    });
+    const storage = new ThemeFileStorage(this.swell.workerEnv, flavor);
+    const result = await storage.putFiles(configs);
+    if (result.warnings.length > 0) {
+      logger.warn("[ThemeLoader] Theme cache updated with warnings", {
+        total: configs.length,
+        written: result.written,
+        skipped: result.skipped,
+        skippedExisting: result.skippedExisting,
+        warnings: result.warnings.length,
+        trace
+      });
+    } else {
+      logger.info("[ThemeLoader] Theme cache updated successfully", {
+        total: configs.length,
+        written: result.written,
+        skipped: result.skipped,
+        skippedExisting: result.skippedExisting,
+        trace
+      });
     }
-    return this.fetchThemeConfigsFromSourceByPath(filePath, hash);
-  }
-  async fetchThemeConfigsByPath(pathPrefix, pathSuffix) {
-    const paths = this.configPaths.filter(
-      (path) => path.startsWith(pathPrefix) && (!pathSuffix || path.endsWith(pathSuffix))
-    );
-    const configs = await Promise2.map(
-      paths,
-      (path) => this.fetchThemeConfig(path),
-      { concurrency: 10 }
-    );
-    return configs.filter((config) => config !== null);
+    return result;
   }
   /**
-   * Load all theme configs.
+   * Main loading logic - loads all configs at once.
+   * 1. Fetches lightweight metadata (cached when possible)
+   * 2. Batch hydrates file_data from KV
+   * 3. Fetches missing file_data from API if needed
    */
-  async loadThemeAllConfigs() {
-    const { swellHeaders } = this.swell;
-    const configVersion = String(swellHeaders["theme-config-version"]);
-    if (!configVersion) {
-      throw new Error("Theme version is required");
+  async loadAllConfigs() {
+    const configMetadata = await this.fetchConfigMetadata();
+    if (configMetadata.length === 0) {
+      logger.warn("[ThemeLoader] No configs found");
+      return;
     }
-    const configs = await this.getCache().fetch(
-      `configs-all:${this.swell.instanceId}:v@${configVersion}2`,
-      () => this.fetchThemeConfigsFromSource()
-    );
-    return configs?.results ?? [];
+    logger.debug("[ThemeLoader] Loading configs", {
+      total: configMetadata.length
+    });
+    const flavor = getKVFlavor(this.swell.workerEnv);
+    const storage = new ThemeFileStorage(this.swell.workerEnv, flavor);
+    const kvHydrated = await storage.getFiles(configMetadata);
+    const completeConfigs = await this.ensureConfigsHaveData(kvHydrated);
+    for (const config of completeConfigs) {
+      this.configs.set(config.file_path, config);
+    }
+    logger.info("[ThemeLoader] All configs loaded", {
+      total: completeConfigs.length,
+      withData: completeConfigs.filter((c) => c.file_data).length
+    });
   }
   /**
-   * Load theme configs via manifest.
-   *
-   * This approach has the following optimizations:
-   *   - cached manifests and configs can be shared by other clients
-   *   - when fetching from source, only fetch the missing records
+   * Fetch lightweight config metadata from API or cache.
+   * Does NOT include file_data to minimize payload size.
    */
-  async loadThemeFromManifest() {
-    const manifest = await this.fetchManifest();
-    if (!manifest) {
-      return null;
-    }
-    const configHashesUnresolved = [];
-    const configsByHash = /* @__PURE__ */ new Map();
-    const themeId = this.getThemeId();
-    const cache = this.getCache();
-    await Promise2.map(
-      manifest.values(),
-      async (configHash) => {
-        const [themeConfig, fileUrl] = await Promise2.all([
-          cache.get(`config:${configHash}`),
-          themeId ? cache.get(`file:${themeId}:${configHash}`) : void 0
-        ]);
-        if (!themeConfig) {
-          configHashesUnresolved.push(configHash);
-          return;
-        }
-        let config = themeConfig;
-        if (fileUrl && themeConfig.file?.url) {
-          config = {
-            ...themeConfig,
-            file: { ...themeConfig.file, url: fileUrl }
-          };
+  async fetchConfigMetadata() {
+    const query = {
+      ...this.themeVersionQueryFilter(),
+      limit: 1e3,
+      type: "theme",
+      fields: "id, name, type, file, file_path, hash"
+      // NO file_data
+    };
+    try {
+      const cache = new WorkerCacheProxy(this.swell);
+      const versionHash = this.swell.swellHeaders["theme-version-hash"];
+      const cached = await cache.get(
+        "/:themes:configs",
+        query,
+        {
+          version: versionHash || null
         }
-        configsByHash.set(config.hash, config);
-        this.configs.set(config.file_path, config);
-      },
-      { concurrency: 10 }
-    );
-    if (configHashesUnresolved.length > 0) {
-      const configs = await this.fetchThemeConfigsFromSource(
-        // If no configs were resolved, then fetch them all. otherwise fetch
-        // the specific subset of configs.
-        configsByHash.size === 0 ? void 0 : configHashesUnresolved
       );
-      const newConfigs = configs?.results ?? [];
-      for (const config of newConfigs) {
-        configsByHash.set(config.hash, config);
-        this.configs.set(config.file_path, config);
+      if (cached) {
+        logger.debug("[ThemeLoader] Config metadata cache hit");
+        return cached;
       }
-      await Promise2.map(
-        newConfigs,
-        async (config) => {
-          const promises = [this.cacheThemeConfig(config)];
-          if (themeId && config.file?.url) {
-            promises.push(
-              this.cacheThemeFileUrl(themeId, config.hash, config.file.url)
-            );
-          }
-          await Promise2.all(promises);
-        },
-        { concurrency: 10 }
-      );
+    } catch (err) {
+      logger.warn("[ThemeLoader] Cache read failed, fetching from API", err);
     }
-    return Array.from(configsByHash.values());
-  }
-  /**
-   * Caches a theme version manifest by hash.
-   */
-  async cacheManifest(version) {
-    if (version?.hash) {
-      await this.getCache().set(`manifest:${version.hash}`, version.manifest);
+    logger.debug("[ThemeLoader] Fetching config metadata from API");
+    const response = await this.swell.get(
+      "/:themes:configs",
+      query
+    );
+    const configs = response?.results || [];
+    try {
+      const cache = new WorkerCacheProxy(this.swell);
+      const versionHash = this.swell.swellHeaders["theme-version-hash"];
+      await cache.put("/:themes:configs", query, configs, {
+        version: versionHash || null
+      });
+    } catch (err) {
+      logger.warn("[ThemeLoader] Cache write failed", err);
     }
+    return configs;
   }
   /**
-   * Caches a theme config by hash.
+   * Helper to ensure all configs have file_data.
+   * Fetches missing data from API and updates KV cache.
    */
-  async cacheThemeConfig(config) {
-    if (config?.hash) {
-      await this.getCache().set(`config:${config.hash}`, config);
+  async ensureConfigsHaveData(configs) {
+    const missingData = configs.filter((c) => !c.file_data);
+    if (missingData.length === 0) {
+      logger.debug("[ThemeLoader] All configs have file_data from KV");
+      return configs;
     }
-  }
-  /**
-   * Caches a CDN file url by config hash.
-   */
-  async cacheThemeFileUrl(themeId, configHash, fileUrl) {
-    await this.getCache().set(`file:${themeId}:${configHash}`, fileUrl);
-  }
-  /**
-   * Fetches the manifest (set of config hashes) for a theme version.
-   */
-  async fetchManifest() {
-    const { swellHeaders } = this.swell;
-    const versionHash = swellHeaders["theme-version-hash"];
-    console.log("ThemeLoader.fetchManifest", versionHash);
-    let manifest = await this.getCache().get(
-      `manifest:${versionHash}`
+    const trace = createTraceId();
+    logger.info(
+      `[ThemeLoader] Loading ${missingData.length} missing file_data from API`,
+      {
+        trace
+      }
     );
-    if (!manifest) {
-      const themeVersion = await this.swell.get(
-        "/:themes:versions/:last",
-        {
-          ...this.themeVersionQueryFilter(),
-          fields: "hash, manifest"
-        }
-      );
-      if (themeVersion) {
-        await this.cacheManifest(themeVersion);
-        manifest = themeVersion.manifest;
+    const hashes = missingData.map((c) => c.hash);
+    const apiResponse = await this.fetchThemeConfigsFromSource(hashes);
+    const fetched = apiResponse.results || [];
+    logger.info(`[ThemeLoader] Fetched ${fetched.length} configs from API`, {
+      trace
+    });
+    if (fetched.length > 0) {
+      const cacheResult = await this.updateThemeCache({
+        api: 1,
+        // Required by SwellThemePreload type
+        configs: fetched
+      });
+      if (cacheResult.warnings.length > 0) {
+        logger.warn("[ThemeLoader] Some files had size issues", {
+          warnings: cacheResult.warnings.length
+        });
       }
     }
-    if (manifest) {
-      this.manifest = new Map(Object.entries(manifest));
-      this.configPaths = [...this.manifest.keys()];
+    const fetchedMap = new Map(fetched.map((c) => [c.hash, c]));
+    const mergedConfigs = configs.map((config) => {
+      if (!config.file_data) {
+        const withData = fetchedMap.get(config.hash);
+        if (withData?.file_data) {
+          return { ...config, file_data: withData.file_data };
+        }
+      }
+      return config;
+    });
+    const stillMissing = mergedConfigs.filter((c) => !c.file_data).length;
+    if (stillMissing > 0) {
+      logger.warn(
+        `[ThemeLoader] ${stillMissing} configs still missing file_data after fetch`
+      );
     }
-    return this.manifest;
+    return mergedConfigs;
   }
   /**
-   * Fetches many theme configs via Swell Backend API.
+   * Fetches theme configs with file_data from Swell Backend API.
+   * Used to retrieve missing file_data for configs.
    */
   async fetchThemeConfigsFromSource(configHashes = void 0) {
     configHashes = configHashes || [];
     const { swellHeaders } = this.swell;
     const version = String(swellHeaders["theme-config-version"]);
     const fetchAll = configHashes.length === 0 || configHashes.length > MAX_INDIVIDUAL_CONFIGS_TO_FETCH;
-    console.log(
-      `Retrieving ${fetchAll ? "all" : "some"} theme configurations - version: ${version}`
+    logger.debug(
+      `[ThemeLoader] Fetching ${fetchAll ? "all" : configHashes.length} configs with file_data`,
+      { version }
     );
     const configs = await this.swell.get(
       "/:themes:configs",
       {
         ...this.themeVersionQueryFilter(),
         ...fetchAll ? void 0 : { hash: { $in: configHashes } },
-        // TODO: paginate to support more than 1000 configs
         limit: 1e3,
         type: "theme",
         fields: "name, file, file_path, hash",
@@ -19556,45 +20218,13 @@ var ThemeLoader = class _ThemeLoader {
     return configs;
   }
   /**
-   * Fetches one theme config via Swell Backend API.
-   * This is used when a hash entry cannot be found.
-   * We may override the cached hash in order to ensure it is found on reload,
-   * but we probably need to find why that happens in the first place (TODO).
+   * Get the current theme ID from headers.
    */
-  async fetchThemeConfigsFromSourceByPath(filePath, hash) {
-    console.log(`Retrieving theme config - ${filePath}`);
-    const config = await this.swell.get(
-      "/:themes:configs/:last",
-      {
-        ...this.themeVersionQueryFilter(),
-        file_path: filePath,
-        fields: "name, file, file_path, hash",
-        include: {
-          file_data: FILE_DATA_INCLUDE_QUERY
-        }
-      }
-    );
-    if (config) {
-      this.configs.set(filePath, config);
-      if (hash) {
-        config.hash = hash;
-      }
-      const themeId = this.getThemeId();
-      const promises = [this.cacheThemeConfig(config)];
-      if (themeId && config.file?.url) {
-        promises.push(
-          this.cacheThemeFileUrl(themeId, config.hash, config.file.url)
-        );
-      }
-      await Promise2.all(promises);
-    }
-    return config ?? null;
-  }
   getThemeId() {
     return this.swell.swellHeaders["theme-id"];
   }
   /**
-   * Generates a Swell API query filter for this theme version.
+   * Generate a Swell API query filter for this theme version.
    */
   themeVersionQueryFilter() {
     const { swellHeaders } = this.swell;
@@ -19774,7 +20404,6 @@ var SwellTheme3 = class {
   resources;
   liquidSwell;
   themeLoader;
-  themeConfigs = null;
   page;
   pageId;
   shopifyCompatibility = null;
@@ -19808,6 +20437,23 @@ var SwellTheme3 = class {
     });
     this.themeLoader = new ThemeLoader(swell);
   }
+  /**
+   * Getter for theme configs - returns the configs from the loader.
+   * Used by editor and tests to access loaded configs.
+   */
+  get themeConfigs() {
+    const configs = this.themeLoader.getConfigs();
+    return configs.size > 0 ? configs : null;
+  }
+  /**
+   * Setter for theme configs - directly sets configs in the loader.
+   * Used by editor and tests to inject configs without API/KV loading.
+   */
+  set themeConfigs(configs) {
+    if (configs) {
+      this.themeLoader.setConfigs(configs);
+    }
+  }
   getSwellAppThemeProps(swellConfig) {
     return swellConfig?.storefront?.theme || {};
   }
@@ -19881,10 +20527,8 @@ var SwellTheme3 = class {
   }
   async getSettingsAndConfigs() {
     const geo = GEO_DATA;
-    const [storefrontSettings, settingConfigs] = await Promise.all([
-      this.swell.getStorefrontSettings(),
-      this.getThemeConfigsByPath("theme/config/", ".json")
-    ]);
+    const storefrontSettings = await this.swell.getStorefrontSettings();
+    const settingConfigs = this.getThemeConfigsByPath("theme/config/", ".json");
     const configs = {
       theme: {},
       editor: {},
@@ -19979,7 +20623,7 @@ var SwellTheme3 = class {
       $locale: void 0
     };
     if (pageId) {
-      const templateConfig = await this.getThemeTemplateConfigByType(
+      const templateConfig = this._getTemplateConfigByType(
         "templates",
         pageId,
         altTemplate
@@ -20274,7 +20918,7 @@ var SwellTheme3 = class {
     this.shopifyCompatibility.adaptPageData(pageData);
   }
   async getLocaleConfig(localeCode = "en", suffix = ".json") {
-    const allLocaleConfigs = await this.getThemeConfigsByPath(
+    const allLocaleConfigs = this.getThemeConfigsByPath(
       "theme/locales/",
       suffix
     );
@@ -20378,22 +21022,24 @@ var SwellTheme3 = class {
     }
     return resolvedUrl;
   }
-  async getAllThemeConfigs() {
-    if (this.themeConfigs === null) {
-      const configs = await this.themeLoader.loadTheme();
-      const configsByPath = /* @__PURE__ */ new Map();
-      for (const config of configs) {
-        configsByPath.set(config.file_path, config);
-      }
-      this.themeConfigs = configsByPath;
-    }
-    return this.themeConfigs;
-  }
-  /**
-   * Preloads updated theme configs. Used to optimize initial theme load.
-   */
   async preloadThemeConfigs(payload) {
-    await this.themeLoader.preloadTheme(payload);
+    const result = await this.themeLoader.updateThemeCache(payload);
+    if (result.warnings && result.warnings.length > 0) {
+      const rejected = result.warnings.filter(
+        (w) => w.reason === "rejected_5mb" || w.reason === "exceeded_25mb"
+      ).length;
+      const warned = result.warnings.filter(
+        (w) => w.reason === "warning_1mb"
+      ).length;
+      logger.warn("[Theme] File size issues detected during cache update", {
+        totalWarnings: result.warnings.length,
+        rejected,
+        warned,
+        details: result.warnings.slice(0, 5)
+        // Log first 5 warnings for debugging
+      });
+    }
+    return result;
   }
   getPageConfigPath(pageId, altTemplate) {
     if (this.shopifyCompatibility) {
@@ -20406,16 +21052,10 @@ var SwellTheme3 = class {
     return `${withSuffix(`theme/templates/${pageId}`, altTemplate)}.json`;
   }
   async getThemeConfig(filePath) {
-    if (this.themeConfigs !== null) {
-      return this.themeConfigs.get(filePath) ?? null;
-    }
-    return this.themeLoader.fetchThemeConfig(filePath);
+    return this.themeLoader.getConfig(filePath);
   }
-  async getThemeConfigsByPath(pathPrefix, pathSuffix) {
-    const configs = await this.themeLoader.fetchThemeConfigsByPath(
-      pathPrefix,
-      pathSuffix
-    );
+  getThemeConfigsByPath(pathPrefix, pathSuffix) {
+    const configs = this.themeLoader.getConfigsByPath(pathPrefix, pathSuffix);
     const configsByPath = /* @__PURE__ */ new Map();
     for (const config of configs) {
       configsByPath.set(config.file_path, config);
@@ -20423,31 +21063,42 @@ var SwellTheme3 = class {
     return configsByPath;
   }
   async getThemeTemplateConfig(filePath) {
-    if (filePath.endsWith(".json") || filePath.endsWith(".liquid")) {
-      return this.getThemeConfig(filePath);
-    }
-    const jsonTemplate = await this.getThemeConfig(`${filePath}.json`);
-    if (jsonTemplate) {
-      return jsonTemplate;
-    }
-    return this.getThemeConfig(`${filePath}.liquid`);
+    return this._getTemplateConfig(filePath);
   }
-  async getThemeTemplateConfigByType(type, name, suffix) {
+  /**
+   * Internal synchronous helper for getting template configs by type.
+   * Used internally within theme.ts to avoid async overhead.
+   */
+  _getTemplateConfigByType(type, name, suffix) {
     const templatesByPriority = [withSuffix(`${type}/${name}`, suffix)];
     if (this.shopifyCompatibility) {
       const path = this.shopifyCompatibility.getThemeFilePath(type, name);
       templatesByPriority.push(withSuffix(path, suffix));
     }
     for (const filePath of templatesByPriority) {
-      const templateConfig = await this.getThemeTemplateConfig(
-        `theme/${filePath}`
-      );
+      const templateConfig = this._getTemplateConfig(`theme/${filePath}`);
       if (templateConfig) {
         return templateConfig;
       }
     }
     return null;
   }
+  /**
+   * Internal synchronous helper for getting template configs.
+   */
+  _getTemplateConfig(filePath) {
+    if (filePath.endsWith(".json") || filePath.endsWith(".liquid")) {
+      return this.themeLoader.getConfig(filePath);
+    }
+    const jsonTemplate = this.themeLoader.getConfig(`${filePath}.json`);
+    if (jsonTemplate) {
+      return jsonTemplate;
+    }
+    return this.themeLoader.getConfig(`${filePath}.liquid`);
+  }
+  async getThemeTemplateConfigByType(type, name, suffix) {
+    return this._getTemplateConfigByType(type, name, suffix);
+  }
   async getAssetConfig(assetName) {
     return await this.getThemeConfig(`theme/assets/${assetName}`) ?? await this.getThemeConfig(`assets/${assetName}`) ?? null;
   }
@@ -20469,17 +21120,8 @@ var SwellTheme3 = class {
       return "";
     }
     template = unescapeLiquidSyntax(template);
-    const trace = createTraceId();
     try {
-      logger.debug("[SDK] Render template start", {
-        config: config.name,
-        trace
-      });
       const result = await this.liquidSwell.parseAndRender(template, data);
-      logger.debug("[SDK] Render template end", {
-        config: config.name,
-        trace
-      });
       return result;
     } catch (err) {
       logger.error(err);
@@ -20496,10 +21138,7 @@ var SwellTheme3 = class {
   }
   async getSectionSchema(sectionName) {
     let result;
-    const config = await this.getThemeTemplateConfigByType(
-      "sections",
-      sectionName
-    );
+    const config = this._getTemplateConfigByType("sections", sectionName);
     if (config?.file_path?.endsWith(".json")) {
       try {
         result = JSON56.parse(config.file_data) || void 0;
@@ -20577,10 +21216,7 @@ var SwellTheme3 = class {
     return content;
   }
   async renderLayoutTemplate(name, data) {
-    const templateConfig = await this.getThemeTemplateConfigByType(
-      "layouts",
-      name
-    );
+    const templateConfig = this._getTemplateConfigByType("layouts", name);
     if (!templateConfig) {
       throw new Error(`Layout template not found: ${name}`);
     }
@@ -20615,17 +21251,14 @@ ${content.slice(pos)}`;
   async renderPageTemplate(name, data, altTemplateId) {
     let templateConfig = null;
     if (altTemplateId) {
-      templateConfig = await this.getThemeTemplateConfigByType(
+      templateConfig = this._getTemplateConfigByType(
         "templates",
         name,
         altTemplateId
       );
     }
     if (!templateConfig) {
-      templateConfig = await this.getThemeTemplateConfigByType(
-        "templates",
-        name
-      );
+      templateConfig = this._getTemplateConfigByType("templates", name);
     }
     if (templateConfig) {
       const templatePath = name.split("/").splice(1).join("/") || null;
@@ -20726,7 +21359,7 @@ ${content.slice(pos)}`;
     }
     const [sectionKey, originalPageId] = sectionId.split(/__/).reverse();
     const pageId = (originalPageId || "").replaceAll("_", "/");
-    const templateConfig = await this.getThemeTemplateConfigByType(
+    const templateConfig = this._getTemplateConfigByType(
       pageId ? "templates" : "sections",
       pageId ? pageId : sectionKey
     );
@@ -20901,7 +21534,7 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
     return defaults;
   }
   async getAllSections() {
-    const configs = await this.getThemeConfigsByPath("theme/sections/");
+    const configs = this.getThemeConfigsByPath("theme/sections/");
     return getAllSections(configs, this.getTemplateSchema.bind(this));
   }
   async getPageSections(sectionGroup, resolveSettings = true) {
@@ -20928,7 +21561,7 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
     const sectionName = sectionSchema?.label || sectionFileName;
     let sourcePath = "";
     if (group) {
-      const sectionConfig = await this.getThemeTemplateConfigByType(
+      const sectionConfig = this._getTemplateConfigByType(
         "sections",
         `${sectionFileName}.json`
       );
@@ -20945,7 +21578,7 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
    * Get a list of sections and section groups in a page layout.
    */
   async getPageSectionGroups(pageId, altTemplate) {
-    const pageConfig = await this.getThemeTemplateConfigByType(
+    const pageConfig = this._getTemplateConfigByType(
       "templates",
       pageId,
       altTemplate
@@ -21012,7 +21645,7 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
       sectionConfigs.map(async (sectionConfig, index) => {
         const { section, schema } = sectionConfig;
         const settings = schema?.fields && this.globals ? resolveSectionSettings(this, sectionConfig, index) : { ...sectionConfig.settings };
-        const templateConfig = await this.getThemeTemplateConfigByType(
+        const templateConfig = this._getTemplateConfigByType(
           "sections",
           `${section.type}.liquid`
         );
@@ -21704,21 +22337,30 @@ export {
   StorefrontResource,
   Swell,
   SwellAccount,
+  SwellAddresses,
   SwellBackendAPI,
   SwellBlog,
   SwellBlogCategory,
   SwellCart,
+  SwellCategories,
   SwellCategory,
   SwellError,
   SwellOrder,
+  SwellOrders,
   SwellPage,
+  SwellPredictiveSearch,
   SwellProduct,
+  SwellProductRecommendations,
+  SwellSearch,
   SwellStorefrontCollection,
   SwellStorefrontPagination,
   SwellStorefrontRecord,
   SwellStorefrontResource,
   SwellStorefrontSingleton,
+  SwellSubscription,
+  SwellSubscriptions,
   SwellTheme3 as SwellTheme,
+  SwellVariant,
   ThemeColor,
   ThemeFont,
   ThemeForm,
@@ -21750,6 +22392,7 @@ export {
   getEasyblocksComponentDefinitions,
   getEasyblocksPagePropsWithConfigs,
   getEasyblocksPageTemplate,
+  getKVFlavor,
   getLayoutSectionGroups,
   getMenuItemStorefrontUrl,
   getMenuItemUrlAndResource,
@@ -21765,6 +22408,7 @@ export {
   isObject2 as isObject,
   md5,
   removeCircularReferences,
+  resetKVFlavorCache,
   resolveAsyncResources,
   resolveLookupCollection,
   resolveMenuItemUrlAndResource,