@swell/apps-sdk 1.0.148 → 1.0.150

package/dist/index.cjs

@@ -48,7 +48,7 @@ __export(index_exports, {
   ShopifyCart: () => ShopifyCart,
   ShopifyCollection: () => ShopifyCollection,
   ShopifyCollections: () => ShopifyCollections,
-  ShopifyCompatibility: () => ShopifyCompatibility3,
+  ShopifyCompatibility: () => ShopifyCompatibility2,
   ShopifyCustomer: () => ShopifyCustomer,
   ShopifyFont: () => ShopifyFont,
   ShopifyForm: () => ShopifyForm,
@@ -112,6 +112,7 @@ __export(index_exports, {
   getEasyblocksComponentDefinitions: () => getEasyblocksComponentDefinitions,
   getEasyblocksPagePropsWithConfigs: () => getEasyblocksPagePropsWithConfigs,
   getEasyblocksPageTemplate: () => getEasyblocksPageTemplate,
+  getKVFlavor: () => getKVFlavor,
   getLayoutSectionGroups: () => getLayoutSectionGroups,
   getMenuItemStorefrontUrl: () => getMenuItemStorefrontUrl,
   getMenuItemUrlAndResource: () => getMenuItemUrlAndResource,
@@ -119,6 +120,7 @@ __export(index_exports, {
   getPage: () => getPage,
   getPageSections: () => getPageSections,
   getSectionGroupProp: () => getSectionGroupProp,
+  getSectionLocation: () => getSectionLocation,
   getSectionSettingsFromProps: () => getSectionSettingsFromProps,
   getThemeSettingsFromProps: () => getThemeSettingsFromProps,
   isArray: () => isArray2,
@@ -126,6 +128,7 @@ __export(index_exports, {
   isObject: () => isObject2,
   md5: () => md5,
   removeCircularReferences: () => removeCircularReferences,
+  resetKVFlavorCache: () => resetKVFlavorCache,
   resolveAsyncResources: () => resolveAsyncResources,
   resolveLookupCollection: () => resolveLookupCollection,
   resolveMenuItemUrlAndResource: () => resolveMenuItemUrlAndResource,
@@ -459,7 +462,8 @@ var ForloopDrop = class extends import_liquidjs.Drop {
   last;
   rindex;
   rindex0;
-  constructor(length, collection, variable) {
+  parentloop;
+  constructor(length, collection, variable, parent) {
     super();
     this.length = length;
     this.name = `${variable}-${collection}`;
@@ -467,9 +471,10 @@ var ForloopDrop = class extends import_liquidjs.Drop {
     this.index = 1;
     this.index0 = 0;
     this.first = true;
-    this.last = false;
+    this.last = length <= 0;
     this.rindex = length;
     this.rindex0 = length - 1;
+    this.parentloop = parent ?? null;
   }
   next() {
     this.i += 1;
@@ -676,6 +681,8 @@ var StorefrontResource = class {
         switch (prop) {
           // Ignore liquid prop checks
           case "toLiquid":
+            return typeof instance.toLiquid === "function" ? instance.toLiquid : void 0;
+          // Ignore liquid prop checks
           case "next":
             return;
           // Indicate props are thenable
@@ -6668,6 +6675,7 @@ function getSectionSettingsFromProps(props, sectionSchema) {
       }
     ),
     id: sectionSchema.id,
+    type: sectionSchema.id,
     blocks: props.Blocks?.filter(
       (propBlock) => Boolean(propBlock.props.compiled?._component)
     ).map((propBlock) => {
@@ -6688,7 +6696,8 @@ function getSectionSettingsFromProps(props, sectionSchema) {
           { $locale: blockProps.$locale }
         ) || {}
       };
-    })
+    }),
+    location: getSectionLocation(sectionSchema.id)
   };
 }
 function toEasyblocksFieldId(fieldId) {
@@ -6825,6 +6834,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/")) {
@@ -6945,7 +6998,8 @@ async function getLayoutSectionGroups(allSections, renderTemplateSchema) {
 async function getPageSections(sectionGroup, getSchema) {
   const order = Array.isArray(sectionGroup?.order) && sectionGroup.order.length > 0 ? sectionGroup.order : Object.keys(sectionGroup?.sections || {});
   const pageSections = [];
-  for (const key of order) {
+  for (let i = 0; i < order.length; ++i) {
+    const key = order[i];
     const section = sectionGroup.sections?.[key];
     if (!section) {
       continue;
@@ -6967,7 +7021,10 @@ async function getPageSections(sectionGroup, getSchema) {
       section: {
         id,
         ...section,
-        blocks
+        blocks,
+        index0: i,
+        index: i + 1,
+        location: getSectionLocation(section.type)
       }
     };
     pageSections.push({
@@ -7211,6 +7268,15 @@ function extractSettingsFromForm(form, currentSettings) {
     (0, import_lodash_es3.cloneDeep)(currentSettings)
   );
 }
+function getSectionLocation(sectionType) {
+  switch (sectionType) {
+    case "header":
+    case "footer":
+      return sectionType;
+    default:
+      return sectionType ? `custom.${sectionType}` : "template";
+  }
+}
 var SECTION_GROUP_CONTENT = "ContentSections";
 function getSectionGroupProp(sectionId) {
   return `SectionGroup_${sectionId}`;
@@ -7341,12 +7407,441 @@ 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
+var import_bluebird2 = __toESM(require("bluebird"), 1);
+
+// src/cache/kv-variety.ts
+var import_bluebird = __toESM(require("bluebird"), 1);
+var { Promise: Promise2 } = import_bluebird.default;
+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 } = import_bluebird2.default;
+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);
   }
 };
 
@@ -7711,7 +8206,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);
@@ -8120,19 +8615,19 @@ function getContentModel(swell, name) {
     })
   );
 }
-async function getContentList(swell, type, query) {
+function getContentList(swell, type, query) {
   return new SwellStorefrontCollection(swell, `content/${type}`, query);
 }
-async function getContentEntry(swell, type, id, query) {
+function getContentEntry(swell, type, id, query) {
   return new SwellStorefrontRecord(swell, `content/${type}`, id, query);
 }
-async function getPage(swell, id, query) {
+function getPage(swell, id, query) {
   return getContentEntry(swell, "pages", id, query);
 }
-async function getBlogs(swell, query) {
+function getBlogs(swell, query) {
   return getContentList(swell, "blogs", query);
 }
-async function getBlog(swell, id, query) {
+function getBlog(swell, id, query) {
   return getContentEntry(swell, "blogs", id, query);
 }
 
@@ -8942,11 +9437,11 @@ function getRandomId() {
 }
 
 // src/menus.ts
-var import_lodash_es12 = require("lodash-es");
+var import_lodash_es14 = require("lodash-es");
 
 // src/theme.ts
 var import_json56 = __toESM(require("json5"), 1);
-var import_lodash_es11 = require("lodash-es");
+var import_lodash_es13 = require("lodash-es");
 
 // src/compatibility/shopify.ts
 var import_lodash_es7 = require("lodash-es");
@@ -14130,7 +14625,7 @@ __export(shopify_objects_exports, {
 });
 
 // src/compatibility/shopify-objects/image.ts
-function ShopifyImage(_instance, image, options = {}, product, variant) {
+function ShopifyImage(image, options = {}, product, variant) {
   if (image instanceof ShopifyResource) {
     return image.clone();
   }
@@ -14192,7 +14687,7 @@ function ShopifyArticle(instance, blog, blogCategory) {
     id: defer(() => blog.id),
     image: deferWith(
       blog,
-      (blog2) => blog2.image ? ShopifyImage(instance, blog2.image) : void 0
+      (blog2) => blog2.image ? ShopifyImage(blog2.image) : void 0
     ),
     metafields: {},
     published_at: deferWith(
@@ -14282,7 +14777,7 @@ function ShopifyBlog(instance, blogCategory) {
 }
 
 // src/compatibility/shopify-objects/media.ts
-function ShopifyMedia(instance, image, options) {
+function ShopifyMedia(image, options) {
   if (image instanceof ShopifyResource) {
     return image.clone();
   }
@@ -14291,7 +14786,7 @@ function ShopifyMedia(instance, image, options) {
     id: image.id || image.file?.id,
     media_type: options?.media_type ?? "image",
     position: options?.position,
-    preview_image: ShopifyImage(instance, image)
+    preview_image: ShopifyImage(image)
   });
 }
 
@@ -14319,19 +14814,19 @@ function ShopifyVariant(instance, variant, productIn, depth = 0) {
       [product, variant],
       (product2, variant2) => {
         const image = variant2.images?.[0] || product2.images?.[0];
-        return image ? ShopifyImage(instance, image, {}, product2, variant2) : void 0;
+        return image ? ShopifyImage(image, {}, product2, variant2) : void 0;
       }
     ),
     featured_media: deferWith([product, variant], (product2, variant2) => {
       const image = variant2.images?.[0] || product2.images?.[0];
-      return image ? ShopifyMedia(instance, image, { media_type: "image" }) : void 0;
+      return image ? ShopifyMedia(image, { media_type: "image" }) : void 0;
     }),
     id: defer(() => variant.id),
     image: deferWith(
       [product, variant],
       (product2, variant2) => {
         const image = variant2.images?.[0] || product2.images?.[0];
-        return image ? ShopifyImage(instance, image, {}, product2, variant2) : void 0;
+        return image ? ShopifyImage(image, {}, product2, variant2) : void 0;
       }
     ),
     incoming: false,
@@ -14483,11 +14978,11 @@ function ShopifyProduct(instance, product, depth = 0) {
     description: defer(() => product.description),
     featured_image: deferWith(product, (product2) => {
       const image = product2.images?.[0];
-      return image ? ShopifyImage(instance, image, {}, product2) : void 0;
+      return image ? ShopifyImage(image, {}, product2) : void 0;
     }),
     featured_media: deferWith(product, (product2) => {
       const image = product2.images?.[0];
-      return image ? ShopifyMedia(instance, image) : void 0;
+      return image ? ShopifyMedia(image) : void 0;
     }),
     // not used
     first_available_variant: deferWith(product, (product2) => {
@@ -14507,7 +15002,7 @@ function ShopifyProduct(instance, product, depth = 0) {
         return [];
       }
       return product2.images.map(
-        (image, index) => ShopifyImage(instance, image, { position: index + 1 }, product2)
+        (image, index) => ShopifyImage(image, { position: index + 1 }, product2)
       );
     }),
     media: deferWith(product, (product2) => {
@@ -14515,7 +15010,7 @@ function ShopifyProduct(instance, product, depth = 0) {
         return [];
       }
       return product2.images.map(
-        (image, index) => ShopifyMedia(instance, image, {
+        (image, index) => ShopifyMedia(image, {
           media_type: "image",
           position: index + 1
         })
@@ -14745,7 +15240,7 @@ function ShopifyLineItem(instance, item, cart, options = {}) {
       [item.product, item.variant],
       (product, variant) => {
         const image = product?.images?.[0];
-        return image ? ShopifyImage(instance, image, {}, product, variant) : void 0;
+        return image ? ShopifyImage(image, {}, product, variant) : void 0;
       }
     ),
     item_components: (item.bundle_items ?? []).map(
@@ -15151,10 +15646,7 @@ function ShopifyCollection(instance, category) {
       (category2) => convertToShopifySorting(category2.sort_options?.[0].value ?? "")
     ),
     description: defer(() => category.description),
-    featured_image: deferWith(
-      category,
-      (category2) => getFirstImage(instance, category2)
-    ),
+    featured_image: deferWith(category, (category2) => getFirstImage(category2)),
     filters: deferWith(
       category,
       (category2) => (category2?.filter_options ?? []).map(
@@ -15163,7 +15655,7 @@ function ShopifyCollection(instance, category) {
     ),
     handle: defer(() => category.slug),
     id: defer(() => category.id),
-    image: deferWith(category, (category2) => getFirstImage(instance, category2)),
+    image: deferWith(category, (category2) => getFirstImage(category2)),
     metafields: {},
     next_product: void 0,
     previous_product: void 0,
@@ -15183,9 +15675,9 @@ function ShopifyCollection(instance, category) {
     url: deferWith(category, (category2) => `/collections/${category2.slug}`)
   });
 }
-function getFirstImage(instance, category) {
+function getFirstImage(category) {
   const image = category.images?.[0];
-  return image ? ShopifyImage(instance, image) : void 0;
+  return image ? ShopifyImage(image) : void 0;
 }
 function convertToShopifySorting(value) {
   switch (value) {
@@ -16138,38 +16630,29 @@ function ShopifyShop(instance, store) {
   });
 }
 
-// src/compatibility/drops/object-handles.ts
+// src/compatibility/drops/all_products.ts
 var import_liquidjs3 = require("liquidjs");
-var ObjectHandlesDrop = class extends import_liquidjs3.Drop {
+var AllProductsDrop = class extends import_liquidjs3.Drop {
+  #instance;
   #map;
-  constructor(map) {
+  constructor(instance) {
     super();
-    switch (typeof map) {
-      case "object": {
-        if (map === null) {
-          this.#map = /* @__PURE__ */ new Map();
-          break;
-        }
-        this.#map = new Map(
-          map instanceof Map ? map : Object.entries(map)
-        );
-        break;
-      }
-      default:
-        this.#map = /* @__PURE__ */ new Map();
-        break;
-    }
+    this.#instance = instance;
+    this.#map = /* @__PURE__ */ new Map();
   }
   liquidMethodMissing(key) {
     switch (typeof key) {
-      case "string":
-        return this.#map.get(key);
+      case "string": {
+        return this.getProduct(key);
+      }
       case "object": {
-        if (key !== null && "handle" in key) {
-          const { handle } = key;
-          if (typeof handle === "string") {
-            return this.#map.get(handle);
+        if (key !== null) {
+          const obj = key;
+          const id = obj.handle || obj.id || obj._id;
+          if (isLikePromise(id)) {
+            return id.then((id2) => this.getProduct(id2));
           }
+          return this.getProduct(id);
         }
         break;
       }
@@ -16177,58 +16660,42 @@ var ObjectHandlesDrop = class extends import_liquidjs3.Drop {
         break;
     }
   }
+  getProduct(slug) {
+    let resource = this.#map.get(slug);
+    if (resource === void 0 && this.#map.size < 20) {
+      resource = ShopifyProduct(
+        this.#instance,
+        new SwellStorefrontRecord(this.#instance.swell, "products", slug)
+      );
+      this.#map.set(slug, resource);
+    }
+    return resource ?? null;
+  }
 };
 
-// src/compatibility/drops/collections.ts
+// src/compatibility/drops/articles.ts
 var import_liquidjs4 = require("liquidjs");
-var AllCategoryResource = class extends SwellStorefrontRecord {
-  constructor(instance) {
-    super(instance.swell, "categories", "all", {}, () => {
-      const category = {
-        id: "all",
-        slug: "all",
-        name: "Products",
-        products: new SwellStorefrontProducts(instance, { $variants: true })
-      };
-      return category;
-    });
-  }
-};
-var CollectionsDrop = class extends import_liquidjs4.Drop {
+var ArticlesDrop = class extends import_liquidjs4.Drop {
   #instance;
-  #categories;
-  #size;
   #map;
   constructor(instance) {
     super();
     this.#instance = instance;
-    this.#size = Number.NaN;
     this.#map = /* @__PURE__ */ new Map();
   }
   liquidMethodMissing(key) {
     switch (typeof key) {
       case "string": {
-        if (key === "all") {
-          let resource = this.#map.get(key);
-          if (resource === void 0) {
-            resource = ShopifyCollection(
-              this.#instance,
-              new AllCategoryResource(this.#instance)
-            );
-            this.#map.set(key, resource);
-          }
-          return resource;
-        }
-        return this.getCollection(key);
+        return this.getArticle(key);
       }
       case "object": {
         if (key !== null) {
           const obj = key;
           const id = obj.handle || obj.id || obj._id;
           if (isLikePromise(id)) {
-            return id.then((id2) => this.getCollection(id2));
+            return id.then((id2) => this.getArticle(id2));
           }
-          return this.getCollection(id);
+          return this.getArticle(id);
         }
         break;
       }
@@ -16236,48 +16703,158 @@ var CollectionsDrop = class extends import_liquidjs4.Drop {
         break;
     }
   }
-  getCollection(slug) {
+  getArticle(slug) {
     let resource = this.#map.get(slug);
     if (resource === void 0) {
-      resource = ShopifyCollection(
+      resource = ShopifyArticle(
         this.#instance,
-        new SwellStorefrontCategory(this.#instance, slug)
+        new SwellStorefrontRecord(this.#instance.swell, "content/blogs", slug)
       );
       this.#map.set(slug, resource);
     }
     return resource;
   }
-  get size() {
-    if (!Number.isFinite(this.#size)) {
-      return this.#instance.swell.storefront.get("/categories/:count").then((count) => {
-        const size = Number(count ?? 0);
-        this.#size = size;
-        return size;
-      });
-    }
-    return this.#size;
-  }
-  [Symbol.iterator]() {
-    return this.iterator();
-  }
-  async iterator() {
-    if (!this.#categories) {
-      this.#categories = await this.#instance.swell.storefront.categories.list().then((res) => {
-        return res.results.map(
-          (category) => ShopifyCollection(
-            this.#instance,
-            new SwellStorefrontCategory(this.#instance, category.slug)
-          )
-        );
-      });
-    }
-    return this.#categories.values();
-  }
 };
-var SwellStorefrontCategory = class extends SwellStorefrontRecord {
-  constructor(instance, id, query) {
-    super(instance.swell, "categories", id, query, async () => {
-      const category = new SwellStorefrontRecord(
+
+// src/compatibility/drops/blogs.ts
+var import_liquidjs5 = require("liquidjs");
+var BlogsDrop = class extends import_liquidjs5.Drop {
+  #instance;
+  #map;
+  constructor(instance) {
+    super();
+    this.#instance = instance;
+    this.#map = /* @__PURE__ */ new Map();
+  }
+  liquidMethodMissing(key) {
+    switch (typeof key) {
+      case "string": {
+        return this.getBlog(key);
+      }
+      case "object": {
+        if (key !== null) {
+          const obj = key;
+          const id = obj.handle || obj.id || obj._id;
+          if (isLikePromise(id)) {
+            return id.then((id2) => this.getBlog(id2));
+          }
+          return this.getBlog(id);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  getBlog(slug) {
+    let resource = this.#map.get(slug);
+    if (resource === void 0) {
+      resource = ShopifyBlog(
+        this.#instance,
+        new SwellStorefrontRecord(
+          this.#instance.swell,
+          "content/blog-categories",
+          slug
+        )
+      );
+      this.#map.set(slug, resource);
+    }
+    return resource;
+  }
+};
+
+// src/compatibility/drops/collections.ts
+var import_liquidjs6 = require("liquidjs");
+var AllCategoryResource = class extends StorefrontResource {
+  constructor(instance) {
+    super(() => {
+      const category = {
+        id: "all",
+        slug: "all",
+        name: "Products",
+        products: new SwellStorefrontProducts(instance, { $variants: true })
+      };
+      return category;
+    });
+  }
+};
+var CollectionsDrop = class extends import_liquidjs6.Drop {
+  #instance;
+  #map;
+  constructor(instance) {
+    super();
+    this.#instance = instance;
+    this.#map = /* @__PURE__ */ new Map();
+  }
+  liquidMethodMissing(key) {
+    switch (typeof key) {
+      case "string": {
+        if (key === "all") {
+          let resource = this.#map.get(key);
+          if (resource === void 0) {
+            resource = ShopifyCollection(
+              this.#instance,
+              new AllCategoryResource(this.#instance)
+            );
+            this.#map.set(key, resource);
+          }
+          return resource;
+        }
+        return this.getCollection(key);
+      }
+      case "object": {
+        if (key !== null) {
+          const obj = key;
+          const id = obj.handle || obj.id || obj._id;
+          if (isLikePromise(id)) {
+            return id.then((id2) => this.getCollection(id2));
+          }
+          return this.getCollection(id);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  getCollection(slug) {
+    let resource = this.#map.get(slug);
+    if (resource === void 0) {
+      resource = ShopifyCollection(
+        this.#instance,
+        new SwellStorefrontCategory(this.#instance, slug)
+      );
+      this.#map.set(slug, resource);
+    }
+    return resource;
+  }
+};
+var Collections = class extends SwellStorefrontCollection {
+  #drop;
+  constructor(instance) {
+    super(instance.swell, "categories", {}, async () => {
+      const response = await this._defaultGetter().call(this);
+      if (!response) {
+        return null;
+      }
+      return {
+        ...response,
+        page_count: response.page_count || 0,
+        results: response.results.map(
+          (item) => ShopifyCollection(instance, item)
+        )
+      };
+    });
+    this.#drop = new CollectionsDrop(instance);
+  }
+  toLiquid() {
+    return this.#drop;
+  }
+};
+var SwellStorefrontCategory = class extends StorefrontResource {
+  constructor(instance, id, query) {
+    super(async () => {
+      const category = new SwellStorefrontRecord(
         instance.swell,
         "categories",
         id,
@@ -16317,8 +16894,168 @@ var SwellStorefrontProducts = class extends SwellStorefrontCollection {
   }
 };
 
+// src/compatibility/drops/images.ts
+var import_liquidjs7 = require("liquidjs");
+var ImagesDrop = class extends import_liquidjs7.Drop {
+  #instance;
+  #map;
+  constructor(instance) {
+    super();
+    this.#instance = instance;
+    this.#map = /* @__PURE__ */ new Map();
+  }
+  liquidMethodMissing(key) {
+    switch (typeof key) {
+      case "string": {
+        return this.getImage(key);
+      }
+      case "object": {
+        if (key !== null) {
+          const obj = key;
+          const id = obj.handle || obj.id || obj._id;
+          if (isLikePromise(id)) {
+            return id.then((id2) => this.getImage(id2));
+          }
+          return this.getImage(id);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  getImage(name) {
+    let resource = this.#map.get(name);
+    if (resource === void 0) {
+      resource = ShopifyImage(new SwellImage(this.#instance.swell, name));
+      this.#map.set(name, resource);
+    }
+    return resource;
+  }
+};
+var SwellImage = class extends StorefrontResource {
+  constructor(swell, name) {
+    super(async () => {
+      const files = await swell.get("/:files", {
+        private: { $ne: true },
+        content_type: { $regex: "^image/" },
+        filename: name
+      });
+      const file = files?.results[0] ?? null;
+      if (file === null) {
+        return null;
+      }
+      return { file };
+    });
+  }
+};
+
+// src/compatibility/drops/object-handles.ts
+var import_liquidjs8 = require("liquidjs");
+var ObjectHandlesDrop = class extends import_liquidjs8.Drop {
+  #map;
+  constructor(map) {
+    super();
+    switch (typeof map) {
+      case "object": {
+        if (map === null) {
+          this.#map = /* @__PURE__ */ new Map();
+          break;
+        }
+        this.#map = new Map(
+          map instanceof Map ? map : Object.entries(map)
+        );
+        break;
+      }
+      default:
+        this.#map = /* @__PURE__ */ new Map();
+        break;
+    }
+  }
+  liquidMethodMissing(key) {
+    switch (typeof key) {
+      case "string":
+        return this.#map.get(key);
+      case "object": {
+        if (key !== null && "handle" in key) {
+          const { handle } = key;
+          if (typeof handle === "string") {
+            return this.#map.get(handle);
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+};
+
+// src/compatibility/drops/pages.ts
+var import_liquidjs9 = require("liquidjs");
+var PagesDrop = class extends import_liquidjs9.Drop {
+  #instance;
+  #map;
+  constructor(instance) {
+    super();
+    this.#instance = instance;
+    this.#map = /* @__PURE__ */ new Map();
+  }
+  liquidMethodMissing(key) {
+    switch (typeof key) {
+      case "string": {
+        return this.getPage(key);
+      }
+      case "object": {
+        if (key !== null) {
+          const obj = key;
+          const id = obj.handle || obj.id || obj._id;
+          if (isLikePromise(id)) {
+            return id.then((id2) => this.getPage(id2));
+          }
+          return this.getPage(id);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  getPage(slug) {
+    let resource = this.#map.get(slug);
+    if (resource === void 0) {
+      resource = ShopifyPage(
+        this.#instance,
+        new SwellStorefrontRecord(this.#instance.swell, "content/pages", slug)
+      );
+      this.#map.set(slug, resource);
+    }
+    return resource;
+  }
+};
+var Pages = class extends SwellStorefrontCollection {
+  #drop;
+  constructor(instance) {
+    super(instance.swell, "content/pages", {}, async () => {
+      const response = await this._defaultGetter().call(this);
+      if (!response) {
+        return null;
+      }
+      return {
+        ...response,
+        page_count: response.page_count || 0,
+        results: response.results.map((page) => ShopifyPage(instance, page))
+      };
+    });
+    this.#drop = new PagesDrop(instance);
+  }
+  toLiquid() {
+    return this.#drop;
+  }
+};
+
 // src/compatibility/shopify.ts
-var ShopifyCompatibility3 = class {
+var ShopifyCompatibility2 = class {
   theme;
   swell;
   pageId;
@@ -16339,9 +17076,25 @@ var ShopifyCompatibility3 = class {
   }
   initGlobals(globals) {
     const { request, page } = globals;
+    globals.additional_checkout_buttons = false;
+    globals.all_products = new AllProductsDrop(this);
+    globals.articles = new ArticlesDrop(this);
+    globals.blogs = new BlogsDrop(this);
+    globals.closest = {};
+    globals.collections = new Collections(this);
+    globals.content_for_additional_checkout_buttons = "";
+    globals.content_for_header = "";
+    globals.content_for_index = "";
+    globals.content_for_layout = "";
+    globals.current_page = this.swell.queryParams.page || 1;
+    globals.images = new ImagesDrop(this);
+    globals.linklists = null;
+    globals.localization = null;
+    globals.metaobjects = {};
     globals.page = {
       ...page || void 0
     };
+    globals.pages = new Pages(this);
     globals.request = {
       ...request || void 0,
       design_mode: this.swell.isEditor,
@@ -16349,9 +17102,11 @@ var ShopifyCompatibility3 = class {
       // TODO: Add support for visual section preview
       page_type: page?.id
     };
-    globals.collections = new CollectionsDrop(this);
-    globals.current_page = this.swell.queryParams.page || 1;
     globals.routes = this.getPageRoutes();
+    globals.scripts = {};
+    globals.shop = null;
+    globals.template = {};
+    globals.theme = {};
   }
   adaptGlobals(globals, prevGlobals) {
     if (globals.page) {
@@ -16372,11 +17127,6 @@ var ShopifyCompatibility3 = class {
     if (globals.menus) {
       globals.linklists = new ObjectHandlesDrop(globals.menus);
     }
-    if (globals.geo) {
-      const countryOptions = this.getAllCountryOptionTags(globals.geo);
-      globals.all_country_option_tags = countryOptions;
-      globals.country_option_tags = countryOptions;
-    }
     if (globals.store) {
       globals.shop = this.getShopData(globals.store);
       const request = globals.request || prevGlobals.request;
@@ -16888,20 +17638,6 @@ ${injects.join("\n")}</script>`;
       }
     ];
   }
-  getAllCountryOptionTags(geoSettings) {
-    if (!geoSettings) {
-      return "";
-    }
-    return geoSettings.countries?.map((country) => {
-      if (!country) return "";
-      const provinces = (geoSettings.states || []).filter((state) => state.country === country.id).map((state) => [state.id, state.name]);
-      const provincesEncoded = JSON.stringify(provinces).replace(
-        /"/g,
-        "&quot;"
-      );
-      return `<option value="${country.id}" data-provinces="${provincesEncoded}">${country.name}</option>`;
-    }).filter(Boolean).join("\n");
-  }
   // returns true if this URL is used for script actions
   isScriptFormActionUrl(url) {
     if (!url) {
@@ -16957,25 +17693,41 @@ function ShopifyTemplate(_instance, template) {
   );
 }
 
-// src/compatibility/drops/render.ts
-var import_liquidjs5 = require("liquidjs");
-var RenderDrop = class extends import_liquidjs5.Drop {
+// src/liquid/drops/render.ts
+var import_liquidjs10 = require("liquidjs");
+var import_lodash_es8 = require("lodash-es");
+var RenderDrop = class extends import_liquidjs10.Drop {
+  #result;
+  #handler;
   constructor(handler) {
     super();
-    this.handler = handler;
+    this.#result = void 0;
+    this.#handler = handler;
   }
-  valueOf() {
-    return this.handler();
+  /**
+   * For `Drop` we usually use `valueOf` to convert the `object` to a `string`.
+   * Use `then` instead of `valueOf` since `valueOf` doesn't work for `Promise`.
+   */
+  then(onfulfilled, onrejected) {
+    if (this.#handler !== import_lodash_es8.noop) {
+      this.#result = Promise.resolve().then(this.#handler).then((result) => {
+        this.#result = result;
+        return this.#result;
+      }).then(onfulfilled, onrejected);
+      this.#handler = import_lodash_es8.noop;
+      return;
+    }
+    onfulfilled(this.#result);
   }
 };
 
 // src/liquid/index.ts
-var import_liquidjs25 = require("liquidjs");
+var import_liquidjs30 = require("liquidjs");
 
 // src/liquid/tags/assign.ts
-var import_liquidjs6 = require("liquidjs");
+var import_liquidjs11 = require("liquidjs");
 function bind(_liquidSwell) {
-  return class AssignTag extends import_liquidjs6.Tag {
+  return class AssignTag extends import_liquidjs11.Tag {
     key;
     value;
     identifier;
@@ -16987,7 +17739,7 @@ function bind(_liquidSwell) {
       this.tokenizer.skipBlank();
       this.tokenizer.advance();
       try {
-        this.value = new import_liquidjs6.Value(this.tokenizer.readFilteredValue(), this.liquid);
+        this.value = new import_liquidjs11.Value(this.tokenizer.readFilteredValue(), this.liquid);
       } catch (e) {
         console.warn(
           `Liquid "assign" tag: ${e instanceof Error ? e.stack : String(e)}`
@@ -17014,9 +17766,9 @@ function bind(_liquidSwell) {
 }
 
 // src/liquid/tags/case.ts
-var import_liquidjs7 = require("liquidjs");
+var import_liquidjs12 = require("liquidjs");
 function bind2(liquidSwell) {
-  return class CaseTag extends import_liquidjs7.Tag {
+  return class CaseTag extends import_liquidjs12.Tag {
     value;
     branches;
     elseTemplates;
@@ -17027,7 +17779,7 @@ function bind2(liquidSwell) {
       const caseVar = this.tokenizer.readValue()?.getText();
       this.isBlock = Boolean(caseVar?.startsWith("block."));
       this.tokenizer.p = begin;
-      this.value = new import_liquidjs7.Value(this.tokenizer.readFilteredValue(), this.liquid);
+      this.value = new import_liquidjs12.Value(this.tokenizer.readFilteredValue(), this.liquid);
       this.branches = [];
       this.elseTemplates = [];
       let p = [];
@@ -17065,12 +17817,12 @@ function bind2(liquidSwell) {
     }
     *render(ctx, emitter) {
       const r = this.liquid.renderer;
-      const target = (0, import_liquidjs7.toValue)(yield this.value.value(ctx, ctx.opts.lenientIf));
+      const target = (0, import_liquidjs12.toValue)(yield this.value.value(ctx, ctx.opts.lenientIf));
       let branchHit = false;
       let output = "";
       for (const branch of this.branches) {
         for (const valueToken of branch.values) {
-          const value = yield (0, import_liquidjs7.evalToken)(valueToken, ctx, ctx.opts.lenientIf);
+          const value = yield (0, import_liquidjs12.evalToken)(valueToken, ctx, ctx.opts.lenientIf);
           if (target === value) {
             const blockOutput = yield r.renderTemplates(branch.templates, ctx);
             output += this.isBlock && liquidSwell.isEditor ? `<span class="swell-block">${blockOutput}</span>` : blockOutput;
@@ -17103,15 +17855,15 @@ function bind2(liquidSwell) {
 }
 
 // src/liquid/tags/comment.ts
-var import_liquidjs8 = require("liquidjs");
+var import_liquidjs13 = require("liquidjs");
 function bind3(_liquidSwell) {
-  return class CommentTag extends import_liquidjs8.Tag {
+  return class CommentTag extends import_liquidjs13.Tag {
     constructor(tagToken, remainTokens, liquid) {
       super(tagToken, remainTokens, liquid);
       let nested = 1;
       while (remainTokens.length > 0) {
         const token = remainTokens.shift();
-        if (import_liquidjs8.TypeGuards.isTagToken(token)) {
+        if (import_liquidjs13.TypeGuards.isTagToken(token)) {
           switch (token.name) {
             case "comment":
               nested += 1;
@@ -17136,20 +17888,22 @@ function bind3(_liquidSwell) {
 }
 
 // src/liquid/tags/for.ts
-var import_liquidjs9 = require("liquidjs");
+var import_liquidjs14 = require("liquidjs");
 var MODIFIERS = Object.freeze(["offset", "limit", "reversed"]);
 function bind4(_liquidSwell) {
-  return class ForTag extends import_liquidjs9.ForTag {
+  return class ForTag extends import_liquidjs14.ForTag {
     *render(ctx, emitter) {
       const r = this.liquid.renderer;
-      let collection = yield (0, import_liquidjs9.evalToken)(this.collection, ctx);
+      let collection = yield (0, import_liquidjs14.evalToken)(this.collection, ctx);
       collection = yield resolveEnumerable(collection);
       if (!collection.length) {
         yield r.renderTemplates(this.elseTemplates, ctx, emitter);
         return;
       }
       const continueKey = "continue-" + this.variable + "-" + this.collection.getText();
-      ctx.push({ continue: ctx.getRegister(continueKey) });
+      ctx.push({
+        continue: ctx.getRegister(continueKey)
+      });
       const hash = yield this.hash.render(ctx);
       ctx.pop();
       const modifiers = this.liquid.options.orderedFilterParameters ? Object.keys(hash).filter((x) => MODIFIERS.includes(x)) : MODIFIERS.filter((x) => hash[x] !== void 0);
@@ -17165,23 +17919,29 @@ function bind4(_liquidSwell) {
             return collection2;
         }
       }, collection);
-      ctx.setRegister(continueKey, (hash["offset"] || 0) + collection.length);
+      const length = Math.min(collection.length, 50);
+      const parent = ctx.getRegister("parentloop");
+      ctx.setRegister(continueKey, (hash["offset"] || 0) + length);
+      const forloop = new ForloopDrop(
+        length,
+        this.collection.getText(),
+        this.variable,
+        parent
+      );
       const scope = {
-        forloop: new ForloopDrop(
-          collection.length,
-          this.collection.getText(),
-          this.variable
-        )
+        forloop
       };
       ctx.push(scope);
-      for (const item of collection) {
-        scope[this.variable] = item;
+      ctx.setRegister("parentloop", forloop);
+      for (let i = 0; i < length; ++i) {
+        scope[this.variable] = collection[i];
         ctx.continueCalled = ctx.breakCalled = false;
         yield r.renderTemplates(this.templates, ctx, emitter);
         if (ctx.breakCalled) break;
         scope.forloop.next();
       }
       ctx.continueCalled = ctx.breakCalled = false;
+      ctx.setRegister("parentloop", parent);
       ctx.pop();
     }
   };
@@ -17197,10 +17957,10 @@ function limit(arr, count) {
 }
 
 // src/liquid/tags/form.ts
-var import_liquidjs10 = require("liquidjs");
+var import_liquidjs15 = require("liquidjs");
 var IGNORED_SHOPIFY_FORMS = Object.freeze(["new_comment", "guest_login"]);
 function bind5(liquidSwell) {
-  return class FormTag extends import_liquidjs10.Tag {
+  return class FormTag extends import_liquidjs15.Tag {
     formType;
     formConfig;
     templates;
@@ -17214,10 +17974,10 @@ function bind5(liquidSwell) {
       tokenizer.advance();
       this.arg = tokenizer.readValue();
       this.templates = [];
-      this.hash = new import_liquidjs10.Hash(this.tokenizer.remaining());
+      this.hash = new import_liquidjs15.Hash(this.tokenizer.remaining());
       while (remainTokens.length > 0) {
         const token2 = remainTokens.shift();
-        if (import_liquidjs10.TypeGuards.isTagToken(token2) && token2.name === "endform") {
+        if (import_liquidjs15.TypeGuards.isTagToken(token2) && token2.name === "endform") {
           return;
         }
         this.templates.push(parser.parseToken(token2, remainTokens));
@@ -17235,7 +17995,7 @@ function bind5(liquidSwell) {
         return;
       }
       const r = this.liquid.renderer;
-      const arg = yield (0, import_liquidjs10.evalToken)(this.arg, ctx);
+      const arg = yield (0, import_liquidjs15.evalToken)(this.arg, ctx);
       const hash = yield this.hash.render(ctx);
       const scope = ctx.getAll();
       const attrs = " " + Object.entries(hash).reduce((acc, [key, value]) => {
@@ -17290,14 +18050,15 @@ function bind5(liquidSwell) {
           ${html}
         </form>
       `);
+      ctx.pop();
     }
   };
 }
 
 // src/liquid/tags/if.ts
-var import_liquidjs11 = require("liquidjs");
+var import_liquidjs16 = require("liquidjs");
 function bind6(_liquidSwell) {
-  return class IfTag extends import_liquidjs11.Tag {
+  return class IfTag extends import_liquidjs16.Tag {
     branches = [];
     elseTemplates;
     constructor(tagToken, remainTokens, liquid, parser) {
@@ -17306,22 +18067,22 @@ function bind6(_liquidSwell) {
       parser.parseStream(remainTokens).on(
         "start",
         () => this.branches.push({
-          value: new import_liquidjs11.Value(
+          value: new import_liquidjs16.Value(
             tagToken.tokenizer.readFilteredValue(),
             this.liquid
           ),
           templates: p = []
         })
       ).on("tag:elsif", (token) => {
-        (0, import_liquidjs11.assert)(!this.elseTemplates, "unexpected elsif after else");
+        (0, import_liquidjs16.assert)(!this.elseTemplates, "unexpected elsif after else");
         this.branches.push({
-          value: new import_liquidjs11.Value(token.tokenizer.readFilteredValue(), this.liquid),
+          value: new import_liquidjs16.Value(token.tokenizer.readFilteredValue(), this.liquid),
           templates: p = []
         });
       }).on("tag:else", (tag) => {
         if (tag.args.length > 0) {
           this.branches.push({
-            value: new import_liquidjs11.Value(tag.tokenizer.readFilteredValue(), this.liquid),
+            value: new import_liquidjs16.Value(tag.tokenizer.readFilteredValue(), this.liquid),
             templates: p = []
           });
         } else {
@@ -17339,7 +18100,7 @@ function bind6(_liquidSwell) {
       const r = this.liquid.renderer;
       for (const { value, templates } of this.branches) {
         const v = yield value.value(ctx, ctx.opts.lenientIf);
-        if ((0, import_liquidjs11.isTruthy)(v, ctx)) {
+        if ((0, import_liquidjs16.isTruthy)(v, ctx)) {
           yield r.renderTemplates(templates, ctx, emitter);
           return;
         }
@@ -17360,20 +18121,20 @@ function bind6(_liquidSwell) {
   };
 }
 function assertEmpty(predicate, message = `unexpected ${JSON.stringify(predicate)}`) {
-  (0, import_liquidjs11.assert)(!predicate, message);
+  (0, import_liquidjs16.assert)(!predicate, message);
 }
 
 // src/liquid/tags/javascript.ts
-var import_liquidjs12 = require("liquidjs");
+var import_liquidjs17 = require("liquidjs");
 function bind7(_liquidSwell) {
-  return class JavascriptTag extends import_liquidjs12.Tag {
+  return class JavascriptTag extends import_liquidjs17.Tag {
     templates;
     constructor(token, remainTokens, liquid, parser) {
       super(token, remainTokens, liquid);
       this.templates = [];
       while (remainTokens.length > 0) {
         const token2 = remainTokens.shift();
-        if (import_liquidjs12.TypeGuards.isTagToken(token2) && token2.name === "endjavascript") {
+        if (import_liquidjs17.TypeGuards.isTagToken(token2) && token2.name === "endjavascript") {
           return;
         }
         this.templates.push(parser.parseToken(token2, remainTokens));
@@ -17391,9 +18152,9 @@ function bind7(_liquidSwell) {
 }
 
 // src/liquid/tags/layout.ts
-var import_liquidjs13 = require("liquidjs");
+var import_liquidjs18 = require("liquidjs");
 function bind8(liquidSwell) {
-  return class LayoutTag extends import_liquidjs13.Tag {
+  return class LayoutTag extends import_liquidjs18.Tag {
     fileName;
     constructor(token, remainTokens, liquid, _parser) {
       super(token, remainTokens, liquid);
@@ -17409,9 +18170,9 @@ function bind8(liquidSwell) {
 }
 
 // src/liquid/tags/paginate.ts
-var import_liquidjs14 = require("liquidjs");
+var import_liquidjs19 = require("liquidjs");
 function bind9(liquidSwell) {
-  return class PaginateTag extends import_liquidjs14.Tag {
+  return class PaginateTag extends import_liquidjs19.Tag {
     collection;
     pageSize;
     templates;
@@ -17426,7 +18187,7 @@ function bind9(liquidSwell) {
       }
       this.templates = [];
       this.collection = collection;
-      this.hash = new import_liquidjs14.Hash(this.tokenizer.remaining());
+      this.hash = new import_liquidjs19.Hash(this.tokenizer.remaining());
       const stream = parser.parseStream(remainTokens).on("tag:endpaginate", () => stream.stop()).on("template", (tpl) => {
         this.templates.push(tpl);
       }).on("end", () => {
@@ -17436,10 +18197,10 @@ function bind9(liquidSwell) {
     }
     *render(ctx, emitter) {
       const r = this.liquid.renderer;
-      const collection = yield (0, import_liquidjs14.evalToken)(this.collection, ctx);
-      const pageSize = Number(yield (0, import_liquidjs14.evalToken)(this.pageSize, ctx));
+      const collection = yield (0, import_liquidjs19.evalToken)(this.collection, ctx);
+      const pageSize = Number(yield (0, import_liquidjs19.evalToken)(this.pageSize, ctx));
       const hash = yield this.hash.render(ctx);
-      if (!Number.isNaN(pageSize) && collection instanceof SwellStorefrontCollection && collection.limit != pageSize) {
+      if (!Number.isNaN(pageSize) && collection instanceof SwellStorefrontCollection && collection.limit !== pageSize) {
         yield collection._get({
           limit: pageSize,
           window: hash.window_size || void 0
@@ -17455,15 +18216,18 @@ function bind9(liquidSwell) {
         ctx.push({ paginate });
       }
       yield r.renderTemplates(this.templates, ctx, emitter);
+      if (collection) {
+        ctx.pop();
+      }
     }
   };
 }
 
 // src/liquid/tags/render.ts
-var import_lodash_es8 = require("lodash-es");
-var import_liquidjs15 = require("liquidjs");
+var import_lodash_es9 = require("lodash-es");
+var import_liquidjs20 = require("liquidjs");
 function bind10(liquidSwell) {
-  return class RenderTag extends import_liquidjs15.RenderTag {
+  return class RenderTag extends import_liquidjs20.RenderTag {
     *render(ctx, emitter) {
       const { liquid, hash } = this;
       const filepath = yield renderFilePath(
@@ -17471,23 +18235,23 @@ function bind10(liquidSwell) {
         ctx,
         liquid
       );
-      (0, import_liquidjs15.assert)(filepath, () => `illegal file path "${filepath}"`);
+      (0, import_liquidjs20.assert)(filepath, () => `illegal file path "${filepath}"`);
       const themeConfig = yield liquidSwell.getComponentPath(filepath).then(
         (fileName) => liquidSwell.getThemeConfig(fileName)
       );
       const childCtx = ctx.spawn();
       const scope = childCtx.bottom();
-      (0, import_lodash_es8.assign)(scope, yield hash.render(ctx));
+      (0, import_lodash_es9.assign)(scope, yield hash.render(ctx));
       const parentSection = yield ctx._get(["section"]);
-      if (parentSection) (0, import_lodash_es8.assign)(scope, { section: parentSection });
+      if (parentSection) (0, import_lodash_es9.assign)(scope, { section: parentSection });
       if (this["with"]) {
         const { value, alias } = this["with"];
         const aliasName = alias || filepath;
-        scope[aliasName] = yield (0, import_liquidjs15.evalToken)(value, ctx);
+        scope[aliasName] = yield (0, import_liquidjs20.evalToken)(value, ctx);
       }
       if (this["for"]) {
         const { value, alias } = this["for"];
-        let collection = yield (0, import_liquidjs15.evalToken)(value, ctx);
+        let collection = yield (0, import_liquidjs20.evalToken)(value, ctx);
         collection = yield resolveEnumerable(collection);
         scope["forloop"] = new ForloopDrop(
           collection.length,
@@ -17520,13 +18284,13 @@ function* renderFilePath(file, ctx, liquid) {
     default:
       break;
   }
-  return yield (0, import_liquidjs15.evalToken)(file, ctx);
+  return yield (0, import_liquidjs20.evalToken)(file, ctx);
 }
 
 // src/liquid/tags/section.ts
-var import_liquidjs16 = require("liquidjs");
+var import_liquidjs21 = require("liquidjs");
 function bind11(liquidSwell) {
-  return class SectionTag extends import_liquidjs16.Tag {
+  return class SectionTag extends import_liquidjs21.Tag {
     fileName;
     constructor(token, remainTokens, liquid, _parser) {
       super(token, remainTokens, liquid);
@@ -17558,7 +18322,8 @@ function bind11(liquidSwell) {
           section: {
             id: this.fileName,
             settings: { ...defaultSettings, blocks: void 0 },
-            blocks: defaultSettings.blocks
+            blocks: defaultSettings.blocks,
+            location: "static"
           }
         });
       });
@@ -17576,10 +18341,10 @@ function bind11(liquidSwell) {
 }
 
 // src/liquid/tags/sections.ts
-var import_liquidjs17 = require("liquidjs");
+var import_liquidjs22 = require("liquidjs");
 var import_json54 = __toESM(require("json5"), 1);
 function bind12(liquidSwell) {
-  return class SectionsTag extends import_liquidjs17.Tag {
+  return class SectionsTag extends import_liquidjs22.Tag {
     fileName;
     constructor(token, remainTokens, liquid, _parser) {
       super(token, remainTokens, liquid);
@@ -17618,9 +18383,9 @@ function bind12(liquidSwell) {
 }
 
 // src/liquid/tags/style.ts
-var import_liquidjs18 = require("liquidjs");
+var import_liquidjs23 = require("liquidjs");
 function bind13(_liquidSwell) {
-  return class StyleTag extends import_liquidjs18.Tag {
+  return class StyleTag extends import_liquidjs23.Tag {
     templates;
     hash;
     constructor(token, remainTokens, liquid, parser) {
@@ -17629,7 +18394,7 @@ function bind13(_liquidSwell) {
       const tagBegin = token.begin;
       while (remainTokens.length > 0) {
         const token2 = remainTokens.shift();
-        if (import_liquidjs18.TypeGuards.isTagToken(token2) && token2.name === "endstyle") {
+        if (import_liquidjs23.TypeGuards.isTagToken(token2) && token2.name === "endstyle") {
           this.hash = md5(token2.input.slice(tagBegin, token2.end));
           return;
         }
@@ -17652,16 +18417,16 @@ function bind13(_liquidSwell) {
 }
 
 // src/liquid/tags/stylesheet.ts
-var import_liquidjs19 = require("liquidjs");
+var import_liquidjs24 = require("liquidjs");
 function bind14(_liquidSwell) {
-  return class StyleSheetTag extends import_liquidjs19.Tag {
+  return class StyleSheetTag extends import_liquidjs24.Tag {
     templates;
     constructor(token, remainTokens, liquid, parser) {
       super(token, remainTokens, liquid);
       this.templates = [];
       while (remainTokens.length > 0) {
         const token2 = remainTokens.shift();
-        if (import_liquidjs19.TypeGuards.isTagToken(token2) && token2.name === "endstylesheet") {
+        if (import_liquidjs24.TypeGuards.isTagToken(token2) && token2.name === "endstylesheet") {
           return;
         }
         this.templates.push(parser.parseToken(token2, remainTokens));
@@ -17677,9 +18442,9 @@ function bind14(_liquidSwell) {
 }
 
 // src/liquid/tags/shopify/include.ts
-var import_liquidjs20 = require("liquidjs");
+var import_liquidjs25 = require("liquidjs");
 function bind15(liquidSwell) {
-  return class IncludeTag extends import_liquidjs20.IncludeTag {
+  return class IncludeTag extends import_liquidjs25.IncludeTag {
     *render(ctx, emitter) {
       const { hash } = this;
       const filepath = yield renderFilePath(
@@ -17687,13 +18452,13 @@ function bind15(liquidSwell) {
         ctx,
         this.liquid
       );
-      (0, import_liquidjs20.assert)(filepath, () => `illegal file path "${filepath}"`);
+      (0, import_liquidjs25.assert)(filepath, () => `illegal file path "${filepath}"`);
       const saved = ctx.saveRegister("blocks", "blockMode");
       ctx.setRegister("blocks", {});
       ctx.setRegister("blockMode", 0);
       const scope = yield hash.render(ctx);
       if (this.withVar) {
-        scope[filepath] = yield (0, import_liquidjs20.evalToken)(this.withVar, ctx);
+        scope[filepath] = yield (0, import_liquidjs25.evalToken)(this.withVar, ctx);
       }
       ctx.push(ctx.opts.jekyllInclude ? { include: scope } : scope);
       const output = yield liquidSwell.getComponentPath(filepath).then((path) => liquidSwell.getThemeConfig(path)).then((themeConfig) => liquidSwell.renderTemplate(themeConfig, scope));
@@ -17705,10 +18470,10 @@ function bind15(liquidSwell) {
 }
 
 // src/liquid/tags/shopify/schema.ts
-var import_liquidjs21 = require("liquidjs");
+var import_liquidjs26 = require("liquidjs");
 var import_json55 = __toESM(require("json5"), 1);
 function bind16(liquidSwell) {
-  return class SchemaTag extends import_liquidjs21.Tag {
+  return class SchemaTag extends import_liquidjs26.Tag {
     templates;
     constructor(token, remainTokens, liquid, parser) {
       super(token, remainTokens, liquid);
@@ -17741,9 +18506,9 @@ function bind16(liquidSwell) {
 }
 
 // src/liquid/tags/inline_editable.ts
-var import_liquidjs22 = require("liquidjs");
+var import_liquidjs27 = require("liquidjs");
 function bind17(_liquidSwell) {
-  return class InlineEditableTag extends import_liquidjs22.Tag {
+  return class InlineEditableTag extends import_liquidjs27.Tag {
     key;
     value;
     constructor(token, remainTokens, liquid, _parser) {
@@ -17995,12 +18760,12 @@ function bind35(_liquidSwell) {
 }
 
 // src/liquid/filters/embedded_content.ts
-var import_lodash_es9 = require("lodash-es");
+var import_lodash_es10 = require("lodash-es");
 function bind36(_liquidSwell) {
   return (value, tag = "iframe") => {
     const escapeIframes = value.replaceAll(`<${tag}`, `&lt;${tag}`).replaceAll(`</${tag}`, `&lt;/${tag}`);
     const removeTags = escapeIframes.replaceAll(/<(.*?)>/gi, "");
-    const unescaped = (0, import_lodash_es9.unescape)(removeTags);
+    const unescaped = (0, import_lodash_es10.unescape)(removeTags);
     const replaceSpaces = unescaped.replaceAll("&nbsp;", " ");
     return replaceSpaces;
   };
@@ -18075,10 +18840,10 @@ var format_address_default = {
 };
 
 // src/liquid/filters/handleize.ts
-var import_lodash_es10 = require("lodash-es");
+var import_lodash_es11 = require("lodash-es");
 function bind40(_liquidSwell) {
   return function filterHandleize(handle) {
-    return (0, import_lodash_es10.kebabCase)(handle);
+    return (0, import_lodash_es11.kebabCase)(handle);
   };
 }
 
@@ -18803,9 +19568,9 @@ async function resolveAsyncProps(propArg, resolveProps) {
 }
 
 // src/liquid/operators.ts
-var import_liquidjs23 = require("liquidjs");
+var import_liquidjs28 = require("liquidjs");
 var swellOperators = {
-  ...import_liquidjs23.defaultOperators,
+  ...import_liquidjs28.defaultOperators,
   "==": equal,
   "!=": (l, r) => !equal(l, r),
   contains: (l, r) => {
@@ -18832,8 +19597,8 @@ function arrayEqual(lhs, rhs) {
 
 // src/liquid/color.ts
 var import_color = __toESM(require("color"), 1);
-var import_liquidjs24 = require("liquidjs");
-var ThemeColor = class _ThemeColor extends import_liquidjs24.Drop {
+var import_liquidjs29 = require("liquidjs");
+var ThemeColor = class _ThemeColor extends import_liquidjs29.Drop {
   color;
   colorValues;
   red;
@@ -18968,7 +19733,7 @@ function isThemeColorLike(value) {
 }
 
 // src/liquid/index.ts
-var LiquidSwell29 = class extends import_liquidjs25.Liquid {
+var LiquidSwell29 = class extends import_liquidjs30.Liquid {
   theme;
   getThemeConfig;
   getThemeTemplateConfigByType;
@@ -19092,296 +19857,255 @@ function getLiquidFS(getThemeConfig, extName) {
 }
 
 // src/theme/theme-loader.ts
-var import_bluebird = __toESM(require("bluebird"), 1);
-var { Promise: Promise2 } = import_bluebird.default;
 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",
@@ -19393,45 +20117,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;
@@ -19447,6 +20139,161 @@ var ThemeLoader = class _ThemeLoader {
   }
 };
 
+// src/globals.ts
+var import_lodash_es12 = require("lodash-es");
+
+// src/compatibility/drops/robots-rule.ts
+var import_liquidjs31 = require("liquidjs");
+var RobotsRule = class _RobotsRule extends import_liquidjs31.Drop {
+  constructor(directive, value) {
+    super();
+    this.directive = directive;
+    this.value = value;
+  }
+  static from(directive, value) {
+    return new _RobotsRule(directive, value);
+  }
+  valueOf() {
+    return `${this.directive}: ${this.value}
+`;
+  }
+};
+
+// src/globals.ts
+async function getFirstFilledValue(values) {
+  for (const promise of values) {
+    const value = await promise;
+    if (value) {
+      return value;
+    }
+  }
+}
+function getRecordGlobals(theme, record) {
+  const globals = {};
+  globals.handle = new RenderDrop(() => record.slug);
+  globals.page_title = new RenderDrop(
+    () => getFirstFilledValue([
+      record.meta_title,
+      // filled SEO
+      record.name,
+      // all records
+      record.title,
+      // content/pages, content/blogs, content/blog-categories
+      theme.page?.title,
+      // default page title
+      theme.globals.store?.name
+      // fallback to store name
+    ])
+  );
+  globals.page_description = new RenderDrop(
+    () => getFirstFilledValue([
+      record.meta_description,
+      // filled SEO
+      record.description,
+      // product and category
+      record.summary,
+      // content/blogs
+      theme.page?.description
+    ])
+  );
+  globals.page_image = new RenderDrop(
+    () => getFirstFilledValue([
+      record.images,
+      // product and category
+      record.image
+      // article
+    ]).then((images) => {
+      if (typeof images !== "object" || images === null) {
+        return;
+      }
+      const image = Array.isArray(images) ? images[0] : images;
+      return image ? ShopifyImage(image) : void 0;
+    })
+  );
+  return globals;
+}
+var POWERED_BY_LINK = '<a target="_blank" rel="nofollow" href="https://www.swell.is/?utm_campaign=poweredby&amp;utm_medium=swell&amp;utm_source=onlinestore">Powered by Swell</a>';
+function getAllCountryOptionTags(geoSettings) {
+  if (!geoSettings) {
+    return "";
+  }
+  const stateMap = (geoSettings.states || []).reduce((map, state) => {
+    let list = map.get(state.country);
+    if (list === void 0) {
+      list = [];
+      map.set(state.country, list);
+    }
+    list.push(state);
+    return map;
+  }, /* @__PURE__ */ new Map());
+  return (geoSettings.countries || []).map((country) => {
+    if (!country) return "";
+    const provinces = (stateMap.get(country.id) || []).map((state) => [
+      state.id,
+      state.name
+    ]);
+    const provincesEncoded = JSON.stringify(provinces).replace(
+      /"/g,
+      "&quot;"
+    );
+    return `<option value="${country.id}" data-provinces="${provincesEncoded}">${country.name}</option>`;
+  }).filter(Boolean).join("\n");
+}
+function getRobotsGlobals(canonicalUrl) {
+  const sitemapUrl = `${(0, import_lodash_es12.trimEnd)(canonicalUrl, "/")}/sitemap.xml`;
+  const defaultRules = [
+    { directive: "Disallow", value: "/admin" },
+    { directive: "Disallow", value: "/cart" },
+    { directive: "Disallow", value: "/account" },
+    { directive: "Disallow", value: "/search" },
+    { directive: "Disallow", value: "/categories/*sort_by*" },
+    { directive: "Disallow", value: "/*/categories/*sort_by*" }
+  ];
+  return {
+    default_groups: [
+      {
+        user_agent: RobotsRule.from("User-agent", "*"),
+        // sitemap: RobotsRule.from('Sitemap', sitemapUrl),
+        rules: defaultRules.map(
+          (rule) => RobotsRule.from(rule.directive, rule.value)
+        )
+      },
+      {
+        user_agent: RobotsRule.from("User-agent", "AhrefsBot"),
+        // sitemap: RobotsRule.from('Sitemap', sitemapUrl),
+        rules: [
+          RobotsRule.from("Crawl-delay", "10"),
+          ...defaultRules.map(
+            (rule) => RobotsRule.from(rule.directive, rule.value)
+          )
+        ]
+      },
+      {
+        user_agent: RobotsRule.from("User-agent", "AhrefsSiteAudit"),
+        // sitemap: RobotsRule.from('Sitemap', sitemapUrl),
+        rules: [
+          RobotsRule.from("Crawl-delay", "10"),
+          ...defaultRules.map(
+            (rule) => RobotsRule.from(rule.directive, rule.value)
+          )
+        ]
+      },
+      {
+        user_agent: RobotsRule.from("User-agent", "Nutch"),
+        rules: [RobotsRule.from("Crawl-delay", "10")]
+      },
+      {
+        user_agent: RobotsRule.from("User-agent", "MJ12bot"),
+        rules: [RobotsRule.from("Crawl-delay", "10")]
+      },
+      {
+        user_agent: RobotsRule.from("User-agent", "Pinterest"),
+        rules: [RobotsRule.from("Crawl-delay", "1")]
+      }
+    ]
+  };
+}
+
 // src/theme.ts
 var SwellTheme3 = class {
   swell;
@@ -19456,11 +20303,10 @@ var SwellTheme3 = class {
   resources;
   liquidSwell;
   themeLoader;
-  themeConfigs = null;
   page;
   pageId;
   shopifyCompatibility = null;
-  shopifyCompatibilityClass = ShopifyCompatibility3;
+  shopifyCompatibilityClass = ShopifyCompatibility2;
   shopifyCompatibilityConfig = null;
   formData = {};
   globalData = {};
@@ -19475,7 +20321,7 @@ var SwellTheme3 = class {
     this.globals = globals || {};
     this.forms = forms;
     this.resources = resources;
-    this.shopifyCompatibilityClass = shopifyCompatibilityClass || ShopifyCompatibility3;
+    this.shopifyCompatibilityClass = shopifyCompatibilityClass || ShopifyCompatibility2;
     this.liquidSwell = new LiquidSwell29({
       theme: this,
       getThemeConfig: this.getThemeConfig.bind(this),
@@ -19490,11 +20336,30 @@ 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 || {};
   }
-  async initGlobals(pageId, altTemplate) {
+  async initGlobals(pageId, options) {
     this.pageId = pageId;
+    const pageRecord = options?.pageRecord;
+    const altTemplate = options?.altTemplate;
     const trace = createTraceId();
     logger.debug("[SDK] Theme init start", { page: pageId, trace });
     await this.themeLoader.init(this.themeConfigs || void 0);
@@ -19504,6 +20369,7 @@ var SwellTheme3 = class {
     const { settings, request, page, cart, account, customer } = await this.resolvePageData(store, configs, pageId, altTemplate);
     logger.debug("[SDK] Theme page data load done", { page: pageId, trace });
     this.page = page;
+    const countryOptions = getAllCountryOptionTags(geo);
     const globals = {
       ...this.globalData,
       // return all storefront settings in the store
@@ -19519,10 +20385,24 @@ var SwellTheme3 = class {
       geo,
       configs,
       language: configs?.language,
+      ...pageRecord ? getRecordGlobals(this, pageRecord) : {
+        page_title: page.title,
+        page_description: page.description
+      },
+      all_country_option_tags: countryOptions,
+      country_option_tags: countryOptions,
       canonical_url: `${store.url}${this.swell.url?.pathname || ""}`,
+      powered_by_link: POWERED_BY_LINK,
       // Flag to enable Shopify compatibility in sections and tags/filters
       shopify_compatibility: Boolean(settings.shopify_compatibility)
     };
+    switch (pageId) {
+      case "robots.txt":
+        globals.robots = getRobotsGlobals(globals.canonical_url);
+        break;
+      default:
+        break;
+    }
     if (this.shopifyCompatibility) {
       this.shopifyCompatibility.initGlobals(globals);
     }
@@ -19546,10 +20426,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: {},
@@ -19644,7 +20522,7 @@ var SwellTheme3 = class {
       $locale: void 0
     };
     if (pageId) {
-      const templateConfig = await this.getThemeTemplateConfigByType(
+      const templateConfig = this._getTemplateConfigByType(
         "templates",
         pageId,
         altTemplate
@@ -19857,7 +20735,7 @@ var SwellTheme3 = class {
       return languageConfig;
     }
     const localeShortCode = locale.split("-")[0];
-    return (0, import_lodash_es11.reduce)(
+    return (0, import_lodash_es13.reduce)(
       languageConfig,
       (acc, value, key) => {
         if (isObject2(value)) {
@@ -19881,15 +20759,15 @@ var SwellTheme3 = class {
             const translationEnd = translationParts.pop();
             const translationPath = translationParts.join(".");
             const translationConfigGlobal = this.globals.language;
-            acc[key] = (0, import_lodash_es11.get)(
+            acc[key] = (0, import_lodash_es13.get)(
               translationConfigGlobal,
               `${translationPath}.$locale.${locale}.${translationEnd}`
-            ) || (0, import_lodash_es11.get)(
+            ) || (0, import_lodash_es13.get)(
               translationConfigGlobal,
               `${translationPath}.$locale.${localeShortCode}.${translationEnd}`
-            ) || (0, import_lodash_es11.get)(translationConfigGlobal, translationKey) || value;
+            ) || (0, import_lodash_es13.get)(translationConfigGlobal, translationKey) || value;
           } else {
-            acc[key] = (0, import_lodash_es11.get)(languageConfig, `$locale.${locale}.${key}`) || (0, import_lodash_es11.get)(languageConfig, `$locale.${localeShortCode}.${key}`) || value;
+            acc[key] = (0, import_lodash_es13.get)(languageConfig, `$locale.${locale}.${key}`) || (0, import_lodash_es13.get)(languageConfig, `$locale.${localeShortCode}.${key}`) || value;
           }
         }
         return acc;
@@ -19904,7 +20782,7 @@ var SwellTheme3 = class {
       }
       return this.shopifyCompatibility;
     };
-    if (!Object.keys(configs.editor).length && configs.settings_schema) {
+    if (Object.keys(configs.editor).length <= 0 && configs.settings_schema) {
       const store = await this.swell.storefront.settings.get("store");
       configs.editor = shopifyCompatibility().getEditorConfig(
         configs.settings_schema
@@ -19915,13 +20793,13 @@ var SwellTheme3 = class {
         store.locale || "en-US"
       );
     }
-    if (!Object.keys(configs.theme).length && configs.settings_data) {
+    if (Object.keys(configs.theme).length <= 0 && configs.settings_data) {
       configs.theme = shopifyCompatibility().getThemeConfig(
         configs.settings_data
       );
       this.themeSettingFilePath = "theme/config/settings_data.json";
     }
-    if (!Object.keys(configs.presets).length && configs.settings_data) {
+    if (Object.keys(configs.presets).length <= 0 && configs.settings_data) {
       configs.presets = shopifyCompatibility().getPresetsConfig(
         configs.settings_data
       );
@@ -19939,7 +20817,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
     );
@@ -20043,22 +20921,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) {
@@ -20071,16 +20951,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);
@@ -20088,33 +20962,47 @@ 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;
+  }
   async getAssetUrl(filePath) {
-    const assetConfig = await this.getThemeConfig(`theme/assets/${filePath}`) || await this.getThemeConfig(`assets/${filePath}`);
+    const assetConfig = await this.getAssetConfig(filePath);
     const file = assetConfig?.file;
     if (!file) {
       return null;
@@ -20131,17 +21019,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);
@@ -20158,10 +21037,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 = import_json56.default.parse(config.file_data) || void 0;
@@ -20239,10 +21115,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}`);
     }
@@ -20277,17 +21150,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;
@@ -20388,7 +21258,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
     );
@@ -20416,13 +21286,42 @@ ${content.slice(pos)}`;
     }
     return "";
   }
-  async renderLayout(layoutName, data) {
+  async renderLayout(layoutName, data, contentForLayout, contentForHeader) {
     layoutName = layoutName || this.liquidSwell.layoutName;
     if (layoutName) {
-      return this.renderLayoutTemplate(layoutName, data);
+      if (data) {
+        data = await this.renderDataFields(data, [
+          "page_title",
+          "page_description"
+        ]);
+      }
+      return this.renderLayoutTemplate(layoutName, {
+        ...data,
+        content_for_layout: contentForLayout,
+        content_for_header: contentForHeader
+      });
     } else {
-      return data?.content_for_layout || "";
+      return contentForLayout || "";
+    }
+  }
+  async renderDataFields(data, fields) {
+    const promises = [];
+    for (const key of fields) {
+      if (typeof data[key] === "string") {
+        promises.push(
+          this.renderTemplateString(data[key], data).then((value) => {
+            if (data) {
+              data[key] = value;
+            }
+          })
+        );
+      }
+    }
+    if (promises.length > 0) {
+      data = { ...data };
+      await Promise.all(promises);
     }
+    return data;
   }
   getContentForHeader() {
     let content = "\n";
@@ -20534,7 +21433,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) {
@@ -20561,7 +21460,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`
       );
@@ -20578,7 +21477,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
@@ -20590,8 +21489,10 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
     const pageLayout = pageSchema.layout || "";
     const pageSectionGroups = [];
     this.pageSectionGroups = pageSectionGroups;
-    await this.renderLayout(pageLayout, {
-      content_for_layout: new RenderDrop(() => {
+    await this.renderLayout(
+      pageLayout,
+      {},
+      new RenderDrop(() => {
         pageSectionGroups.push({
           prop: SECTION_GROUP_CONTENT,
           label: "Template",
@@ -20600,7 +21501,7 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
         });
         return "";
       })
-    });
+    );
     this.pageSectionGroups = null;
     return pageSectionGroups;
   }
@@ -20642,8 +21543,8 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
     return Promise.all(
       sectionConfigs.map(async (sectionConfig, index) => {
         const { section, schema } = sectionConfig;
-        const settings = schema?.fields && this.globals ? resolveSectionSettings(this, sectionConfig) : { ...sectionConfig.settings };
-        const templateConfig = await this.getThemeTemplateConfigByType(
+        const settings = schema?.fields && this.globals ? resolveSectionSettings(this, sectionConfig, index) : { ...sectionConfig.settings };
+        const templateConfig = this._getTemplateConfigByType(
           "sections",
           `${section.type}.liquid`
         );
@@ -20656,7 +21557,7 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
           });
           if (settings?.section?.custom_css) {
             output += `<style>${scopeCustomCSS(
-              settings?.section.custom_css,
+              settings.section.custom_css,
               sectionConfig.id
             )}</style>`;
           }
@@ -20686,8 +21587,8 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
     const keyParts = key?.split(".") || [];
     const keyName = keyParts.pop() || "";
     const keyPath = keyParts.join(".");
-    const langObject = (0, import_lodash_es11.get)(langConfig, keyPath);
-    let localeValue = (0, import_lodash_es11.get)(langObject?.[localeCode], keyName) || (0, import_lodash_es11.get)(langObject?.[localeCode.split("-")[0]], keyName) || langObject?.[keyName];
+    const langObject = (0, import_lodash_es13.get)(langConfig, keyPath);
+    let localeValue = (0, import_lodash_es13.get)(langObject?.[localeCode], keyName) || (0, import_lodash_es13.get)(langObject?.[localeCode.split("-")[0]], keyName) || langObject?.[keyName];
     if (data?.count !== void 0 && localeValue?.one) {
       localeValue = data.count === 1 ? localeValue.one : localeValue.other;
     }
@@ -20721,7 +21622,7 @@ var PageNotFound = class extends PageError {
     super(title, status, description);
   }
 };
-function resolveSectionSettings(theme, sectionConfig) {
+function resolveSectionSettings(theme, sectionConfig, index) {
   const { settings, schema } = sectionConfig;
   if (!schema || !settings?.section?.settings) {
     return settings;
@@ -20752,7 +21653,10 @@ function resolveSectionSettings(theme, sectionConfig) {
         settings.section.settings,
         editorSettings
       ),
-      blocks
+      blocks,
+      index0: index,
+      index: typeof index === "number" ? index + 1 : void 0,
+      location: getSectionLocation(settings.section.type)
     }
   };
 }
@@ -20766,7 +21670,7 @@ function fillDefaultThemeSettings(themeSettings, editorSchemaSettings) {
   }
 }
 function resolveThemeSettings(theme, themeSettings, editorSchemaSettings) {
-  const settings = (0, import_lodash_es11.cloneDeep)(themeSettings);
+  const settings = (0, import_lodash_es13.cloneDeep)(themeSettings);
   if (settings.$locale) {
     const { locale } = theme.swell.getStorefrontLocalization();
     const localeConfig = settings.$locale[locale] || {};
@@ -20776,16 +21680,16 @@ function resolveThemeSettings(theme, themeSettings, editorSchemaSettings) {
       }
     }
   }
-  (0, import_lodash_es11.each)(settings, (value, key) => {
+  (0, import_lodash_es13.each)(settings, (value, key) => {
     const setting = (editorSchemaSettings && findEditorSetting(editorSchemaSettings, key)) ?? null;
     if (isObject2(value) && !(value instanceof StorefrontResource)) {
       switch (setting?.type) {
         case "color_scheme_group": {
-          (0, import_lodash_es11.each)(value, (scheme, schemeId) => {
+          (0, import_lodash_es13.each)(value, (scheme, schemeId) => {
             if (isObject2(scheme) && typeof scheme.settings === "object" && scheme.settings) {
               const settings2 = scheme.settings;
-              (0, import_lodash_es11.each)(settings2, (colorValue, colorId) => {
-                const fieldDef = (0, import_lodash_es11.find)(setting.fields, { id: colorId });
+              (0, import_lodash_es13.each)(settings2, (colorValue, colorId) => {
+                const fieldDef = (0, import_lodash_es13.find)(setting.fields, { id: colorId });
                 if (fieldDef?.type === "color" && colorValue) {
                   scheme.id = schemeId;
                   settings2[colorId] = new ThemeColor(colorValue);
@@ -20836,7 +21740,7 @@ function resolveThemeSettings(theme, themeSettings, editorSchemaSettings) {
 }
 function findThemeSettingsByType(type, themeSettings, editorSchemaSettings) {
   const foundSettings = [];
-  (0, import_lodash_es11.each)(themeSettings, (value, key) => {
+  (0, import_lodash_es13.each)(themeSettings, (value, key) => {
     if (isObject2(value) && !(value instanceof ThemeFont) && !(value instanceof StorefrontResource)) {
       foundSettings.push(
         ...findThemeSettingsByType(type, value, editorSchemaSettings)
@@ -21005,7 +21909,7 @@ function isChildItemActive(items) {
 }
 function getMenuItemValueId(value) {
   const fallback = typeof value === "string" ? value : "";
-  const slug = (0, import_lodash_es12.get)(value, "id", (0, import_lodash_es12.get)(value, "slug", fallback)) || "";
+  const slug = (0, import_lodash_es14.get)(value, "id", (0, import_lodash_es14.get)(value, "slug", fallback)) || "";
   return slug;
 }
 async function getMenuItemUrlAndResource(theme, menuItem) {
@@ -21379,6 +22283,7 @@ function getResourceQuery(slug, query) {
   getEasyblocksComponentDefinitions,
   getEasyblocksPagePropsWithConfigs,
   getEasyblocksPageTemplate,
+  getKVFlavor,
   getLayoutSectionGroups,
   getMenuItemStorefrontUrl,
   getMenuItemUrlAndResource,
@@ -21386,6 +22291,7 @@ function getResourceQuery(slug, query) {
   getPage,
   getPageSections,
   getSectionGroupProp,
+  getSectionLocation,
   getSectionSettingsFromProps,
   getThemeSettingsFromProps,
   isArray,
@@ -21393,6 +22299,7 @@ function getResourceQuery(slug, query) {
   isObject,
   md5,
   removeCircularReferences,
+  resetKVFlavorCache,
   resolveAsyncResources,
   resolveLookupCollection,
   resolveMenuItemUrlAndResource,