@swell/apps-sdk 1.0.149 → 1.0.150

package/dist/index.cjs

@@ -112,6 +112,7 @@ __export(index_exports, {
   getEasyblocksComponentDefinitions: () => getEasyblocksComponentDefinitions,
   getEasyblocksPagePropsWithConfigs: () => getEasyblocksPagePropsWithConfigs,
   getEasyblocksPageTemplate: () => getEasyblocksPageTemplate,
+  getKVFlavor: () => getKVFlavor,
   getLayoutSectionGroups: () => getLayoutSectionGroups,
   getMenuItemStorefrontUrl: () => getMenuItemStorefrontUrl,
   getMenuItemUrlAndResource: () => getMenuItemUrlAndResource,
@@ -127,6 +128,7 @@ __export(index_exports, {
   isObject: () => isObject2,
   md5: () => md5,
   removeCircularReferences: () => removeCircularReferences,
+  resetKVFlavorCache: () => resetKVFlavorCache,
   resolveAsyncResources: () => resolveAsyncResources,
   resolveLookupCollection: () => resolveLookupCollection,
   resolveMenuItemUrlAndResource: () => resolveMenuItemUrlAndResource,
@@ -6832,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/")) {
@@ -7361,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);
   }
 };
 
@@ -7731,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);
@@ -19382,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",
@@ -19683,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;
@@ -19901,7 +20303,6 @@ var SwellTheme3 = class {
   resources;
   liquidSwell;
   themeLoader;
-  themeConfigs = null;
   page;
   pageId;
   shopifyCompatibility = null;
@@ -19935,6 +20336,23 @@ var SwellTheme3 = class {
     });
     this.themeLoader = new ThemeLoader(swell);
   }
+  /**
+   * Getter for theme configs - returns the configs from the loader.
+   * Used by editor and tests to access loaded configs.
+   */
+  get themeConfigs() {
+    const configs = this.themeLoader.getConfigs();
+    return configs.size > 0 ? configs : null;
+  }
+  /**
+   * Setter for theme configs - directly sets configs in the loader.
+   * Used by editor and tests to inject configs without API/KV loading.
+   */
+  set themeConfigs(configs) {
+    if (configs) {
+      this.themeLoader.setConfigs(configs);
+    }
+  }
   getSwellAppThemeProps(swellConfig) {
     return swellConfig?.storefront?.theme || {};
   }
@@ -20008,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: {},
@@ -20106,7 +20522,7 @@ var SwellTheme3 = class {
       $locale: void 0
     };
     if (pageId) {
-      const templateConfig = await this.getThemeTemplateConfigByType(
+      const templateConfig = this._getTemplateConfigByType(
         "templates",
         pageId,
         altTemplate
@@ -20401,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
     );
@@ -20505,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) {
@@ -20533,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);
@@ -20550,31 +20962,42 @@ var SwellTheme3 = class {
     return configsByPath;
   }
   async getThemeTemplateConfig(filePath) {
-    if (filePath.endsWith(".json") || filePath.endsWith(".liquid")) {
-      return this.getThemeConfig(filePath);
-    }
-    const jsonTemplate = await this.getThemeConfig(`${filePath}.json`);
-    if (jsonTemplate) {
-      return jsonTemplate;
-    }
-    return this.getThemeConfig(`${filePath}.liquid`);
+    return this._getTemplateConfig(filePath);
   }
-  async getThemeTemplateConfigByType(type, name, suffix) {
+  /**
+   * Internal synchronous helper for getting template configs by type.
+   * Used internally within theme.ts to avoid async overhead.
+   */
+  _getTemplateConfigByType(type, name, suffix) {
     const templatesByPriority = [withSuffix(`${type}/${name}`, suffix)];
     if (this.shopifyCompatibility) {
       const path = this.shopifyCompatibility.getThemeFilePath(type, name);
       templatesByPriority.push(withSuffix(path, suffix));
     }
     for (const filePath of templatesByPriority) {
-      const templateConfig = await this.getThemeTemplateConfig(
-        `theme/${filePath}`
-      );
+      const templateConfig = this._getTemplateConfig(`theme/${filePath}`);
       if (templateConfig) {
         return templateConfig;
       }
     }
     return null;
   }
+  /**
+   * Internal synchronous helper for getting template configs.
+   */
+  _getTemplateConfig(filePath) {
+    if (filePath.endsWith(".json") || filePath.endsWith(".liquid")) {
+      return this.themeLoader.getConfig(filePath);
+    }
+    const jsonTemplate = this.themeLoader.getConfig(`${filePath}.json`);
+    if (jsonTemplate) {
+      return jsonTemplate;
+    }
+    return this.themeLoader.getConfig(`${filePath}.liquid`);
+  }
+  async getThemeTemplateConfigByType(type, name, suffix) {
+    return this._getTemplateConfigByType(type, name, suffix);
+  }
   async getAssetConfig(assetName) {
     return await this.getThemeConfig(`theme/assets/${assetName}`) ?? await this.getThemeConfig(`assets/${assetName}`) ?? null;
   }
@@ -20596,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);
@@ -20623,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;
@@ -20704,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}`);
     }
@@ -20742,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;
@@ -20853,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
     );
@@ -21028,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) {
@@ -21055,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`
       );
@@ -21072,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
@@ -21139,7 +21544,7 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
       sectionConfigs.map(async (sectionConfig, index) => {
         const { section, schema } = sectionConfig;
         const settings = schema?.fields && this.globals ? resolveSectionSettings(this, sectionConfig, index) : { ...sectionConfig.settings };
-        const templateConfig = await this.getThemeTemplateConfigByType(
+        const templateConfig = this._getTemplateConfigByType(
           "sections",
           `${section.type}.liquid`
         );
@@ -21878,6 +22283,7 @@ function getResourceQuery(slug, query) {
   getEasyblocksComponentDefinitions,
   getEasyblocksPagePropsWithConfigs,
   getEasyblocksPageTemplate,
+  getKVFlavor,
   getLayoutSectionGroups,
   getMenuItemStorefrontUrl,
   getMenuItemUrlAndResource,
@@ -21893,6 +22299,7 @@ function getResourceQuery(slug, query) {
   isObject,
   md5,
   removeCircularReferences,
+  resetKVFlavorCache,
   resolveAsyncResources,
   resolveLookupCollection,
   resolveMenuItemUrlAndResource,