veryfront 0.0.81 → 0.0.82

package/esm/src/cache/multi-tier.js

@@ -0,0 +1,352 @@
+/**
+ * Multi-Tier Cache Abstraction
+ *
+ * Generic implementation for L1 → L2 → L3 cache flows with automatic backfill.
+ * This provides consistent caching behavior across the codebase:
+ *
+ * - L1: In-memory (fastest, per-pod, lost on restart)
+ * - L2: Local disk (fast, per-pod, survives restart)
+ * - L3: Distributed (Redis/API, cross-pod, shared state)
+ *
+ * When a cache hit occurs at a lower tier (e.g., L3), the value is automatically
+ * backfilled to higher tiers (L1, L2) for faster subsequent access.
+ *
+ * @module cache/multi-tier
+ */
+import { rendererLogger as logger } from "../utils/index.js";
+import { withSpan } from "../observability/tracing/otlp-setup.js";
+import { SpanNames } from "../observability/tracing/span-names.js";
+/**
+ * Multi-tier cache implementation.
+ *
+ * Provides automatic fallthrough from L1 → L2 → L3 with backfill on hits.
+ *
+ * @example
+ * ```typescript
+ * const cache = new MultiTierCache({
+ *   name: "http-module",
+ *   l1: new MemoryTier(),
+ *   l3: await CacheBackends.httpModule(),
+ *   defaultTtlSeconds: 86400,
+ * });
+ *
+ * const value = await cache.get("my-key");
+ * // If found in L3, automatically backfills L1
+ * ```
+ */
+export class MultiTierCache {
+    config;
+    stats = {
+        gets: 0,
+        l1Hits: 0,
+        l2Hits: 0,
+        l3Hits: 0,
+        misses: 0,
+        sets: 0,
+        backfills: 0,
+    };
+    constructor(config) {
+        this.config = {
+            defaultTtlSeconds: 300,
+            backfillOnHit: true,
+            asyncBackfill: true,
+            ...config,
+        };
+    }
+    /**
+     * Get a value from the cache.
+     *
+     * Checks tiers in order: L1 → L2 → L3.
+     * On hit at a lower tier, backfills higher tiers.
+     */
+    get(key) {
+        return withSpan(SpanNames.CACHE_MULTI_TIER_GET, async (span) => {
+            this.stats.gets++;
+            span?.setAttribute("cache.name", this.config.name);
+            span?.setAttribute("cache.key", key);
+            // L1: Memory
+            if (this.config.l1) {
+                try {
+                    const value = await this.config.l1.get(key);
+                    if (value !== null) {
+                        this.stats.l1Hits++;
+                        span?.setAttribute("cache.hit_tier", "l1");
+                        logger.debug(`[${this.config.name}] L1 hit`, { key });
+                        return value;
+                    }
+                }
+                catch (error) {
+                    logger.debug(`[${this.config.name}] L1 get error`, { key, error });
+                }
+            }
+            // L2: Disk
+            if (this.config.l2) {
+                try {
+                    const value = await this.config.l2.get(key);
+                    if (value !== null) {
+                        this.stats.l2Hits++;
+                        span?.setAttribute("cache.hit_tier", "l2");
+                        logger.debug(`[${this.config.name}] L2 hit`, { key });
+                        const backfillPromise = this.backfill(key, value, ["l1"]);
+                        if (this.config.asyncBackfill) {
+                            void backfillPromise;
+                        }
+                        else {
+                            await backfillPromise;
+                        }
+                        return value;
+                    }
+                }
+                catch (error) {
+                    logger.debug(`[${this.config.name}] L2 get error`, { key, error });
+                }
+            }
+            // L3: Distributed
+            if (this.config.l3) {
+                try {
+                    const value = await this.config.l3.get(key);
+                    if (value !== null) {
+                        this.stats.l3Hits++;
+                        span?.setAttribute("cache.hit_tier", "l3");
+                        logger.debug(`[${this.config.name}] L3 hit`, { key });
+                        const backfillPromise = this.backfill(key, value, ["l1", "l2"]);
+                        if (this.config.asyncBackfill) {
+                            void backfillPromise;
+                        }
+                        else {
+                            await backfillPromise;
+                        }
+                        return value;
+                    }
+                }
+                catch (error) {
+                    logger.debug(`[${this.config.name}] L3 get error`, { key, error });
+                }
+            }
+            this.stats.misses++;
+            span?.setAttribute("cache.hit_tier", "miss");
+            return null;
+        }, { "cache.operation": "get" });
+    }
+    /**
+     * Set a value in all tiers.
+     *
+     * Writes to all configured tiers in parallel (or sequentially if asyncBackfill=false).
+     */
+    set(key, value, ttlSeconds) {
+        return withSpan(SpanNames.CACHE_MULTI_TIER_SET, (span) => {
+            this.stats.sets++;
+            const ttl = ttlSeconds ?? this.config.defaultTtlSeconds;
+            span?.setAttribute("cache.name", this.config.name);
+            span?.setAttribute("cache.key", key);
+            span?.setAttribute("cache.ttl_seconds", ttl);
+            const tiers = [this.config.l1, this.config.l2, this.config.l3].filter((t) => t !== undefined);
+            const setOps = tiers.map((tier) => tier.set(key, value, ttl).catch((error) => {
+                logger.debug(`[${this.config.name}] Set error in ${tier.name}`, { key, error });
+            }));
+            if (this.config.asyncBackfill) {
+                // Fire-and-forget for performance (don't await)
+                void Promise.all(setOps);
+                return Promise.resolve();
+            }
+            // Wait for all tiers
+            return Promise.all(setOps).then(() => { });
+        }, { "cache.operation": "set" });
+    }
+    /**
+     * Delete a value from all tiers.
+     */
+    async delete(key) {
+        const tiers = [this.config.l1, this.config.l2, this.config.l3].filter((t) => t !== undefined && t.delete !== undefined);
+        await Promise.all(tiers.map((tier) => tier.delete?.(key).catch((error) => {
+            logger.debug(`[${this.config.name}] Delete error in ${tier.name}`, { key, error });
+        })));
+    }
+    /**
+     * Get or compute a value.
+     *
+     * If the key exists in any tier, returns it.
+     * Otherwise, calls the compute function and stores the result in all tiers.
+     */
+    async getOrCompute(key, computeFn, ttlSeconds) {
+        const cached = await this.get(key);
+        if (cached !== null)
+            return cached;
+        const value = await computeFn();
+        await this.set(key, value, ttlSeconds);
+        return value;
+    }
+    /**
+     * Batch get multiple values.
+     *
+     * Uses batch operations where available for efficiency.
+     * Returns a map of key → value (null if not found).
+     */
+    async getBatch(keys) {
+        if (keys.length === 0)
+            return new Map();
+        const results = new Map();
+        let remainingKeys = [...keys];
+        const backfillPromises = [];
+        // Check L1
+        if (this.config.l1 && remainingKeys.length > 0) {
+            try {
+                const l1Results = this.config.l1.getBatch
+                    ? await this.config.l1.getBatch(remainingKeys)
+                    : await this.individualGets(this.config.l1, remainingKeys);
+                for (const [key, value] of l1Results) {
+                    if (value !== null) {
+                        results.set(key, value);
+                        this.stats.l1Hits++;
+                    }
+                }
+                remainingKeys = remainingKeys.filter((k) => !results.has(k) || results.get(k) === null);
+            }
+            catch (error) {
+                logger.debug(`[${this.config.name}] L1 getBatch error`, {
+                    keyCount: remainingKeys.length,
+                    error,
+                });
+            }
+        }
+        // Check L2
+        if (this.config.l2 && remainingKeys.length > 0) {
+            try {
+                const l2Results = this.config.l2.getBatch
+                    ? await this.config.l2.getBatch(remainingKeys)
+                    : await this.individualGets(this.config.l2, remainingKeys);
+                for (const [key, value] of l2Results) {
+                    if (value !== null) {
+                        results.set(key, value);
+                        this.stats.l2Hits++;
+                        backfillPromises.push(this.backfill(key, value, ["l1"]));
+                    }
+                }
+                remainingKeys = remainingKeys.filter((k) => !results.has(k) || results.get(k) === null);
+            }
+            catch (error) {
+                logger.debug(`[${this.config.name}] L2 getBatch error`, {
+                    keyCount: remainingKeys.length,
+                    error,
+                });
+            }
+        }
+        // Check L3
+        if (this.config.l3 && remainingKeys.length > 0) {
+            try {
+                const l3Results = this.config.l3.getBatch
+                    ? await this.config.l3.getBatch(remainingKeys)
+                    : await this.individualGets(this.config.l3, remainingKeys);
+                for (const [key, value] of l3Results) {
+                    if (value !== null) {
+                        results.set(key, value);
+                        this.stats.l3Hits++;
+                        backfillPromises.push(this.backfill(key, value, ["l1", "l2"]));
+                    }
+                    else {
+                        results.set(key, null);
+                        this.stats.misses++;
+                    }
+                }
+            }
+            catch (error) {
+                logger.debug(`[${this.config.name}] L3 getBatch error`, {
+                    keyCount: remainingKeys.length,
+                    error,
+                });
+            }
+        }
+        // Mark remaining as misses
+        for (const key of remainingKeys) {
+            if (!results.has(key)) {
+                results.set(key, null);
+                this.stats.misses++;
+            }
+        }
+        if (backfillPromises.length > 0) {
+            if (this.config.asyncBackfill) {
+                void Promise.all(backfillPromises);
+            }
+            else {
+                await Promise.all(backfillPromises);
+            }
+        }
+        return results;
+    }
+    /**
+     * Get cache statistics.
+     */
+    getStats() {
+        const totalHits = this.stats.l1Hits + this.stats.l2Hits + this.stats.l3Hits;
+        const hitRate = this.stats.gets > 0 ? totalHits / this.stats.gets : 0;
+        return { ...this.stats, hitRate };
+    }
+    /**
+     * Reset statistics.
+     */
+    resetStats() {
+        this.stats = {
+            gets: 0,
+            l1Hits: 0,
+            l2Hits: 0,
+            l3Hits: 0,
+            misses: 0,
+            sets: 0,
+            backfills: 0,
+        };
+    }
+    /**
+     * Backfill higher tiers with a value found at a lower tier.
+     */
+    backfill(key, value, tiers) {
+        if (!this.config.backfillOnHit)
+            return Promise.resolve();
+        this.stats.backfills++;
+        const ttl = this.config.defaultTtlSeconds;
+        const backfillOps = [];
+        if (tiers.includes("l1") && this.config.l1) {
+            backfillOps.push(this.config.l1.set(key, value, ttl).catch((error) => {
+                logger.debug(`[${this.config.name}] L1 backfill error`, { key, error });
+            }));
+        }
+        if (tiers.includes("l2") && this.config.l2) {
+            backfillOps.push(this.config.l2.set(key, value, ttl).catch((error) => {
+                logger.debug(`[${this.config.name}] L2 backfill error`, { key, error });
+            }));
+        }
+        return Promise.all(backfillOps).then(() => { });
+    }
+    /**
+     * Helper for individual gets when batch operation is not available.
+     */
+    async individualGets(tier, keys) {
+        const results = await Promise.all(keys.map(async (key) => [key, await tier.get(key)]));
+        return new Map(results);
+    }
+}
+/**
+ * Create a memory-backed cache tier from a CacheBackend.
+ */
+export function createMemoryTier(backend) {
+    return {
+        name: "memory",
+        get: (key) => backend.get(key),
+        set: (key, value, ttl) => backend.set(key, value, ttl),
+        delete: backend.del?.bind(backend),
+        getBatch: backend.getBatch?.bind(backend),
+        setBatch: backend.setBatch?.bind(backend),
+    };
+}
+/**
+ * Create a distributed cache tier from a CacheBackend.
+ */
+export function createDistributedTier(backend) {
+    return {
+        name: `distributed-${backend.type}`,
+        get: (key) => backend.get(key),
+        set: (key, value, ttl) => backend.set(key, value, ttl),
+        delete: backend.del?.bind(backend),
+        getBatch: backend.getBatch?.bind(backend),
+        setBatch: backend.setBatch?.bind(backend),
+    };
+}

package/esm/src/cli/templates/integration-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integration-loader.d.ts","sourceRoot":"","sources":["../../../../src/src/cli/templates/integration-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAAe,EAqDnD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,EAM3C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,WAAW,EAAE,aAAa,CA8C/D,CAAC;AAqBF;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAanC;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAarC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,eAAe,EAAE,GAAG;IACrE,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAYA;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,gBAAgB,EAAE,eAAe,EAAE,GAClC,OAAO,CAAC;IACT,YAAY,EAAE,mBAAmB,EAAE,CAAC;IACpC,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC,CAyBD;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,WAAW,GAAG,aAAa,CAExE;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,gBAAgB,EAAE,eAAe,EAAE,GAClC,OAAO,CACR,KAAK,CAAC;IACJ,WAAW,EAAE,eAAe,CAAC;IAC7B,OAAO,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC;CACvC,CAAC,CACH,CAcA;AAED;;;GAGG;AACH,wBAAgB,qCAAqC,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAG/E;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAE7E;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,YAAY,EAAE,CAiZxD"}
+{"version":3,"file":"integration-loader.d.ts","sourceRoot":"","sources":["../../../../src/src/cli/templates/integration-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAAe,EAqDnD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,EAM3C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,WAAW,EAAE,aAAa,CA8C/D,CAAC;AAqBF;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAanC;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAQrC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,eAAe,EAAE,GAAG;IACrE,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAYA;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,gBAAgB,EAAE,eAAe,EAAE,GAClC,OAAO,CAAC;IACT,YAAY,EAAE,mBAAmB,EAAE,CAAC;IACpC,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC,CAyBD;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,WAAW,GAAG,aAAa,CAExE;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,gBAAgB,EAAE,eAAe,EAAE,GAClC,OAAO,CACR,KAAK,CAAC;IACJ,WAAW,EAAE,eAAe,CAAC;IAC7B,OAAO,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC;CACvC,CAAC,CACH,CAcA;AAED;;;GAGG;AACH,wBAAgB,qCAAqC,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAE/E;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAE7E;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,YAAY,EAAE,CAiZxD"}

package/esm/src/cli/templates/integration-loader.js

@@ -167,10 +167,9 @@ export async function loadIntegration(integrationName) {
     const config = await loadIntegrationConfig(integrationName);
     if (!config)
         return null;
-    const filesDir = pathHelper.join(getIntegrationDirectory(integrationName), "files");
     return {
         config,
-        files: await loadTemplateFromDirectory(filesDir),
+        files: await loadTemplateFromDirectory(`integration:${integrationName}`),
     };
 }
 /**
@@ -248,8 +247,7 @@ export async function getAvailablePrompts(integrationNames) {
  * These include setup guide page and status API
  */
 export function loadIntegrationBaseFilesFromDirectory() {
-    const filesDir = pathHelper.join(getIntegrationDirectory("_base"), "files");
-    return loadTemplateFromDirectory(filesDir);
+    return loadTemplateFromDirectory("integration:_base");
 }
 /**
  * Load the _base integration config to get shared env vars like APP_URL

package/esm/src/modules/react-loader/ssr-module-loader/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../../src/src/modules/react-loader/ssr-module-loader/loader.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAuCpC,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAG3E;;;;;GAKG;AACH,qBAAa,eAAe;IAId,OAAO,CAAC,OAAO;IAH3B,OAAO,CAAC,EAAE,CAAsB;IAChC,OAAO,CAAC,mBAAmB,CAAuB;gBAE9B,OAAO,EAAE,sBAAsB;IAEnD;;OAEG;IACH,UAAU,CACR,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAuDxD,OAAO,CAAC,mBAAmB;IAiC3B,OAAO,CAAC,wBAAwB;IAwBhC,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,yBAAyB;IAuBjC,OAAO,CAAC,kBAAkB;IAK1B;;OAEG;YACW,2BAA2B;IAkGzC,OAAO,CAAC,yBAAyB;YAiBnB,2BAA2B;IA4MzC;;;OAGG;YACW,mBAAmB;IA2CjC,OAAO,CAAC,yBAAyB;IAYjC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IA4B3B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAuB3B,OAAO,CAAC,wBAAwB;IAehC,OAAO,CAAC,2BAA2B;IAiBnC,OAAO,CAAC,2BAA2B;IAWnC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA4B3B;;OAEG;IACH,OAAO,CAAC,aAAa;YAIP,uBAAuB;IAyCrC;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAUhB;;;OAGG;YACW,gBAAgB;YAgBhB,WAAW;YAeX,YAAY;CAiC3B"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../../src/src/modules/react-loader/ssr-module-loader/loader.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAuCpC,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,YAAY,CAAC;AA2B3E;;;;;GAKG;AACH,qBAAa,eAAe;IAId,OAAO,CAAC,OAAO;IAH3B,OAAO,CAAC,EAAE,CAAsB;IAChC,OAAO,CAAC,mBAAmB,CAAuB;gBAE9B,OAAO,EAAE,sBAAsB;IAEnD;;OAEG;IACH,UAAU,CACR,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAyFxD,OAAO,CAAC,mBAAmB;IAiC3B,OAAO,CAAC,wBAAwB;IAwBhC,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,yBAAyB;IAuBjC,OAAO,CAAC,kBAAkB;IAK1B;;OAEG;YACW,2BAA2B;IAkGzC,OAAO,CAAC,yBAAyB;YAiBnB,2BAA2B;IAyQzC;;;OAGG;YACW,mBAAmB;IA2CjC,OAAO,CAAC,yBAAyB;IAYjC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IA4B3B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAuB3B,OAAO,CAAC,wBAAwB;IAehC,OAAO,CAAC,2BAA2B;IAiBnC,OAAO,CAAC,2BAA2B;IAWnC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA4B3B;;OAEG;IACH,OAAO,CAAC,aAAa;YAIP,uBAAuB;IAyCrC;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAUhB;;;OAGG;YACW,gBAAgB;YAgBhB,WAAW;YAeX,YAAY;CAiC3B"}

package/esm/src/modules/react-loader/ssr-module-loader/loader.js

@@ -22,7 +22,28 @@ import { extractComponent } from "../extract-component.js";
 import { CIRCUIT_BREAKER_RESET_MS, CIRCUIT_BREAKER_THRESHOLD, IN_PROGRESS_WAIT_TIMEOUT_MS, MAX_CONCURRENT_TRANSFORMS, MAX_TRANSFORM_DEPTH, TRANSFORM_ACQUIRE_TIMEOUT_MS, TRANSFORM_BATCH_SIZE, } from "./constants.js";
 import { withTimeoutThrow } from "../../../rendering/utils/stream-utils.js";
 import { failedComponents, getFromRedis, getRedisClientInstance, getRedisEnabled, globalCrossProjectCache, globalInProgress, globalModuleCache, globalTmpDirs, setInRedis, transformSemaphore, } from "./cache/index.js";
-import { getCacheBaseDir } from "../../../utils/cache-dir.js";
+import { getCacheBaseDir, getHttpBundleCacheDir } from "../../../utils/cache-dir.js";
+import { ensureHttpBundlesExist } from "../../../transforms/esm/http-cache.js";
+/** Pattern to match HTTP bundle file:// paths in transformed code */
+const HTTP_BUNDLE_PATTERN = /file:\/\/([^"'\s]+veryfront-http-bundle\/http-([a-f0-9]+)\.mjs)/gi;
+/** Extract HTTP bundle paths from transformed code for proactive recovery */
+function extractHttpBundlePaths(code) {
+    const bundles = [];
+    const seen = new Set();
+    let match;
+    while ((match = HTTP_BUNDLE_PATTERN.exec(code)) !== null) {
+        const path = match[1];
+        const hash = match[2];
+        if (!seen.has(hash)) {
+            seen.add(hash);
+            bundles.push({ path, hash });
+        }
+    }
+    HTTP_BUNDLE_PATTERN.lastIndex = 0;
+    return bundles;
+}
+/** Track temp paths that have been verified for HTTP bundles to avoid redundant I/O */
+const verifiedHttpBundlePaths = new Set();
 /**
  * SSR Module Loader with Redis Support.
  *
@@ -59,7 +80,37 @@ export class SSRModuleLoader {
                         context: { file: filePath, phase: "transform" },
                     }));
                 }
-                const mod = await withSpan(SpanNames.SSR_DYNAMIC_IMPORT, () => import(`file://${cacheEntry.tempPath}?v=${cacheEntry.contentHash}`), { "ssr.file": fileName });
+                let mod;
+                try {
+                    mod = await withSpan(SpanNames.SSR_DYNAMIC_IMPORT, () => import(`file://${cacheEntry.tempPath}?v=${cacheEntry.contentHash}`), { "ssr.file": fileName });
+                }
+                catch (importError) {
+                    // If import fails due to missing HTTP bundle, try to recover and retry once
+                    const errorMsg = importError instanceof Error
+                        ? importError.message
+                        : String(importError);
+                    const bundleMatch = errorMsg.match(/veryfront-http-bundle\/http-([a-f0-9]+)\.mjs/);
+                    if (bundleMatch) {
+                        const hash = bundleMatch[1];
+                        logger.warn("[SSR-MODULE-LOADER] Import failed due to missing HTTP bundle, attempting recovery", {
+                            file: filePath.slice(-40),
+                            hash,
+                        });
+                        const { recoverHttpBundleByHash } = await import("../../../transforms/esm/http-cache.js");
+                        const cacheDir = getHttpBundleCacheDir();
+                        const recovered = await recoverHttpBundleByHash(hash, cacheDir);
+                        if (recovered) {
+                            logger.info("[SSR-MODULE-LOADER] HTTP bundle recovered, retrying import", { hash });
+                            mod = await import(`file://${cacheEntry.tempPath}?v=${cacheEntry.contentHash}&retry=1`);
+                        }
+                        else {
+                            throw importError;
+                        }
+                    }
+                    else {
+                        throw importError;
+                    }
+                }
                 failedComponents.delete(circuitKey);
                 return extractComponent(mod, filePath);
             }
@@ -247,24 +298,80 @@ export class SSRModuleLoader {
         const inProgressKey = contentCacheKey;
         const cachedEntry = globalModuleCache.get(contentCacheKey);
         if (cachedEntry) {
-            globalModuleCache.set(filePathCacheKey, cachedEntry);
-            await this.ensureDependenciesExist(code, filePath, depth);
-            return;
+            // Verify HTTP bundles exist for in-memory cached transforms (once per path)
+            if (!verifiedHttpBundlePaths.has(cachedEntry.tempPath)) {
+                try {
+                    const cachedCode = await this.fs.readTextFile(cachedEntry.tempPath);
+                    const bundlePaths = extractHttpBundlePaths(cachedCode);
+                    if (bundlePaths.length > 0) {
+                        const cacheDir = getHttpBundleCacheDir();
+                        const failed = await ensureHttpBundlesExist(bundlePaths, cacheDir);
+                        if (failed.length > 0) {
+                            logger.warn("[SSR-MODULE-LOADER] In-memory cached module has unrecoverable HTTP bundles, re-transforming", {
+                                file: filePath.slice(-40),
+                                failed,
+                            });
+                            globalModuleCache.delete(contentCacheKey);
+                            globalModuleCache.delete(filePathCacheKey);
+                            // Fall through to Redis or fresh transform
+                        }
+                        else {
+                            verifiedHttpBundlePaths.add(cachedEntry.tempPath);
+                        }
+                    }
+                    else {
+                        verifiedHttpBundlePaths.add(cachedEntry.tempPath);
+                    }
+                }
+                catch {
+                    // File doesn't exist or unreadable, invalidate cache
+                    globalModuleCache.delete(contentCacheKey);
+                    globalModuleCache.delete(filePathCacheKey);
+                }
+            }
+            // Re-check after potential invalidation
+            if (globalModuleCache.has(contentCacheKey)) {
+                globalModuleCache.set(filePathCacheKey, cachedEntry);
+                await this.ensureDependenciesExist(code, filePath, depth);
+                return;
+            }
         }
         const redisEnabled = getRedisEnabled();
         const redisClient = getRedisClientInstance();
         if (redisEnabled && redisClient) {
             const redisCode = await getFromRedis(contentCacheKey);
             if (redisCode) {
-                const tempPath = await this.getTempPath(filePath, contentHash);
-                await this.fs.mkdir(tempPath.substring(0, tempPath.lastIndexOf("/")), { recursive: true });
-                await this.fs.writeTextFile(tempPath, redisCode);
-                const entry = { tempPath, contentHash };
-                globalModuleCache.set(contentCacheKey, entry);
-                globalModuleCache.set(filePathCacheKey, entry);
-                logger.debug("[SSR-MODULE-LOADER] Redis cache hit", { file: filePath.slice(-40) });
-                await this.ensureDependenciesExist(code, filePath, depth);
-                return;
+                // Proactively ensure HTTP bundles exist before using cached transform.
+                // The cached code may reference file:// paths to HTTP bundles that were
+                // created on a different pod and may not exist locally.
+                let httpBundlesOk = true;
+                const bundlePaths = extractHttpBundlePaths(redisCode);
+                if (bundlePaths.length > 0) {
+                    const cacheDir = getHttpBundleCacheDir();
+                    const failed = await ensureHttpBundlesExist(bundlePaths, cacheDir);
+                    if (failed.length > 0) {
+                        logger.warn("[SSR-MODULE-LOADER] Redis cached code has unrecoverable HTTP bundles, re-transforming", {
+                            file: filePath.slice(-40),
+                            failed,
+                        });
+                        httpBundlesOk = false;
+                    }
+                }
+                if (httpBundlesOk) {
+                    const tempPath = await this.getTempPath(filePath, contentHash);
+                    await this.fs.mkdir(tempPath.substring(0, tempPath.lastIndexOf("/")), {
+                        recursive: true,
+                    });
+                    await this.fs.writeTextFile(tempPath, redisCode);
+                    verifiedHttpBundlePaths.add(tempPath);
+                    const entry = { tempPath, contentHash };
+                    globalModuleCache.set(contentCacheKey, entry);
+                    globalModuleCache.set(filePathCacheKey, entry);
+                    logger.debug("[SSR-MODULE-LOADER] Redis cache hit", { file: filePath.slice(-40) });
+                    await this.ensureDependenciesExist(code, filePath, depth);
+                    return;
+                }
+                // Fall through to re-transform, which will create HTTP bundles locally
             }
         }
         const existingTransform = globalInProgress.get(inProgressKey);

package/esm/src/observability/tracing/span-names.d.ts

@@ -80,6 +80,8 @@ export declare const SpanNames: {
     readonly CACHE_REGISTRY_DELETE_REDIS_KEYS: "cache.registry.delete_redis_keys";
     readonly CACHE_KEYS_GET_ALL_ASYNC: "cache.keys.get_all_async";
     readonly CACHE_KEYS_DELETE_ALL_ASYNC: "cache.keys.delete_all_async";
+    readonly CACHE_MULTI_TIER_GET: "cache.multi_tier.get";
+    readonly CACHE_MULTI_TIER_SET: "cache.multi_tier.set";
     readonly HTML_GENERATE_SHELL_PARTS: "html.generate_shell_parts";
     readonly HTML_WRAP_IN_SHELL: "html.wrap_in_shell";
     readonly HTML_GENERATE_TAILWIND_CSS: "html.generate_tailwind_css";

package/esm/src/observability/tracing/span-names.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"span-names.d.ts","sourceRoot":"","sources":["../../../../src/src/observability/tracing/span-names.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4GZ,CAAC"}
+{"version":3,"file":"span-names.d.ts","sourceRoot":"","sources":["../../../../src/src/observability/tracing/span-names.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8GZ,CAAC"}

package/esm/src/observability/tracing/span-names.js

@@ -80,6 +80,8 @@ export const SpanNames = {
     CACHE_REGISTRY_DELETE_REDIS_KEYS: "cache.registry.delete_redis_keys",
     CACHE_KEYS_GET_ALL_ASYNC: "cache.keys.get_all_async",
     CACHE_KEYS_DELETE_ALL_ASYNC: "cache.keys.delete_all_async",
+    CACHE_MULTI_TIER_GET: "cache.multi_tier.get",
+    CACHE_MULTI_TIER_SET: "cache.multi_tier.set",
     HTML_GENERATE_SHELL_PARTS: "html.generate_shell_parts",
     HTML_WRAP_IN_SHELL: "html.wrap_in_shell",
     HTML_GENERATE_TAILWIND_CSS: "html.generate_tailwind_css",

package/esm/src/rendering/orchestrator/module-loader/cache.d.ts

@@ -1,4 +1,12 @@
+/**
+ * Module Loader Cache Utilities
+ *
+ * Provides hash generation and cache factory functions.
+ * Module caches are now pod-level singletons (see src/cache/module-cache.ts)
+ * to ensure caches persist across requests within the same pod.
+ *
+ * @module rendering/orchestrator/module-loader/cache
+ */
+export { createEsmCache, createModuleCache } from "../../../cache/module-cache.js";
 export declare function generateHash(str: string): Promise<string>;
-export declare function createModuleCache(): Map<string, string>;
-export declare function createEsmCache(): Map<string, string>;
 //# sourceMappingURL=cache.d.ts.map

package/esm/src/rendering/orchestrator/module-loader/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../../src/src/rendering/orchestrator/module-loader/cache.ts"],"names":[],"mappings":"AAGA,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAW/D;AAED,wBAAgB,iBAAiB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvD;AAED,wBAAgB,cAAc,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAEpD"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../../src/src/rendering/orchestrator/module-loader/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAInF,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAW/D"}

package/esm/src/rendering/orchestrator/module-loader/cache.js

@@ -1,4 +1,15 @@
+/**
+ * Module Loader Cache Utilities
+ *
+ * Provides hash generation and cache factory functions.
+ * Module caches are now pod-level singletons (see src/cache/module-cache.ts)
+ * to ensure caches persist across requests within the same pod.
+ *
+ * @module rendering/orchestrator/module-loader/cache
+ */
+// Re-export pod-level cache factories
 import * as dntShim from "../../../../_dnt.shims.js";
+export { createEsmCache, createModuleCache } from "../../../cache/module-cache.js";
 const HEX_CHARS = "0123456789abcdef";
 export async function generateHash(str) {
     const data = new TextEncoder().encode(str);
@@ -11,9 +22,3 @@ export async function generateHash(str) {
     }
     return hex;
 }
-export function createModuleCache() {
-    return new Map();
-}
-export function createEsmCache() {
-    return new Map();
-}

package/esm/src/rendering/orchestrator/module-loader/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/rendering/orchestrator/module-loader/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAUzE,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AA+DpE,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,cAAc,CAAC;IACxB,IAAI,EAAE,aAAa,GAAG,YAAY,CAAC;IACnC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAqDD;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,cAAc,EAC5B,MAAM,EAAE,kBAAkB,EAC1B,eAAe,UAAQ,GACtB,OAAO,CAAC,MAAM,CAAC,CAuHjB;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,GAAG,CAAC,CAiB3F"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/rendering/orchestrator/module-loader/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAkBzE,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AA4BpE,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,cAAc,CAAC;IACxB,IAAI,EAAE,aAAa,GAAG,YAAY,CAAC;IACnC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAqDD;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,cAAc,EAC5B,MAAM,EAAE,kBAAkB,EAC1B,eAAe,UAAQ,GACtB,OAAO,CAAC,MAAM,CAAC,CAsIjB;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,GAAG,CAAC,CAmC3F"}