veryfront 0.1.87 → 0.1.88

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "veryfront",
-    "version": "0.1.87",
+    "version": "0.1.88",
     "license": "Apache-2.0",
     "nodeModulesDir": "auto",
     "exclude": [

package/esm/src/cache/distributed-cache-init.d.ts

@@ -4,7 +4,16 @@ interface DistributedCacheStatus {
     ssrModuleCache: boolean;
     fileCache: boolean;
     projectCSSCache: boolean;
+    httpModuleCache: boolean;
 }
+type DistributedCacheInitializers = {
+    transformCache: () => Promise<boolean>;
+    ssrModuleCache: () => Promise<boolean>;
+    fileCache: () => Promise<boolean>;
+    projectCSSCache: () => Promise<boolean>;
+    httpModuleCache: () => Promise<boolean>;
+};
+export declare function __runDistributedCacheInitializationForTests(backend: DistributedCacheStatus["backend"], initializers: DistributedCacheInitializers): Promise<DistributedCacheStatus>;
 export declare function initializeDistributedCaches(): Promise<DistributedCacheStatus>;
 export {};
 //# sourceMappingURL=distributed-cache-init.d.ts.map

package/esm/src/cache/distributed-cache-init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"distributed-cache-init.d.ts","sourceRoot":"","sources":["../../../src/src/cache/distributed-cache-init.ts"],"names":[],"mappings":"AAYA,UAAU,sBAAsB;IAC9B,OAAO,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IAC7C,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;CAC1B;AAaD,wBAAgB,2BAA2B,IAAI,OAAO,CAAC,sBAAsB,CAAC,CA4E7E"}
+{"version":3,"file":"distributed-cache-init.d.ts","sourceRoot":"","sources":["../../../src/src/cache/distributed-cache-init.ts"],"names":[],"mappings":"AAaA,UAAU,sBAAsB;IAC9B,OAAO,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IAC7C,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,KAAK,4BAA4B,GAAG;IAClC,cAAc,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,cAAc,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAClC,eAAe,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACxC,eAAe,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;CACzC,CAAC;AAyFF,wBAAgB,2CAA2C,CACzD,OAAO,EAAE,sBAAsB,CAAC,SAAS,CAAC,EAC1C,YAAY,EAAE,4BAA4B,GACzC,OAAO,CAAC,sBAAsB,CAAC,CAEjC;AAED,wBAAgB,2BAA2B,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAmB7E"}

package/esm/src/cache/distributed-cache-init.js

@@ -1,6 +1,7 @@
 import { initializeFileCacheBackend } from "../platform/adapters/fs/cache/file-cache.js";
 import { initializeSSRDistributedCache } from "../modules/react-loader/ssr-module-loader/index.js";
 import { initializeTransformCache } from "../transforms/esm/transform-cache.js";
+import { initializeHttpModuleDistributedCache } from "../transforms/esm/http-cache-wrapper.js";
 import { SpanNames } from "../observability/tracing/span-names.js";
 import { withSpan } from "../observability/tracing/otlp-setup.js";
 import { initializeProjectCSSCache } from "../html/styles-builder/tailwind-compiler.js";
@@ -8,6 +9,13 @@ import { logger as baseLogger } from "../utils/logger/logger.js";
 import { isRedisConfigured } from "../utils/redis-client.js";
 import { isApiCacheAvailable, isDiskCacheConfigured } from "./backend.js";
 const logger = baseLogger.component("distributed-cache");
+const defaultInitializers = {
+    transformCache: initializeTransformCache,
+    ssrModuleCache: initializeSSRDistributedCache,
+    fileCache: initializeFileCacheBackend,
+    projectCSSCache: initializeProjectCSSCache,
+    httpModuleCache: initializeHttpModuleDistributedCache,
+};
 function determineBackend() {
     if (isApiCacheAvailable())
         return "api";
@@ -20,6 +28,66 @@ function determineBackend() {
 function wasSuccessful(result) {
     return result.status === "fulfilled" && result.value;
 }
+async function initializeDistributedCachesWithInitializers(backend, initializers) {
+    logger.info("Initializing caches...", { backend });
+    const cacheNames = [
+        "transformCache",
+        "ssrModuleCache",
+        "fileCache",
+        "projectCSSCache",
+        "httpModuleCache",
+    ];
+    const results = await Promise.allSettled([
+        initializers.transformCache(),
+        initializers.ssrModuleCache(),
+        initializers.fileCache(),
+        initializers.projectCSSCache(),
+        initializers.httpModuleCache(),
+    ]);
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result && result.status === "rejected") {
+            logger.error(`Cache initialization failed: ${cacheNames[i]}`, {
+                backend,
+                error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+            });
+        }
+    }
+    const status = {
+        backend,
+        transformCache: wasSuccessful(results[0]),
+        ssrModuleCache: wasSuccessful(results[1]),
+        fileCache: wasSuccessful(results[2]),
+        projectCSSCache: wasSuccessful(results[3]),
+        httpModuleCache: wasSuccessful(results[4]),
+    };
+    const enabled = [
+        status.transformCache,
+        status.ssrModuleCache,
+        status.fileCache,
+        status.projectCSSCache,
+        status.httpModuleCache,
+    ].filter(Boolean).length;
+    if (enabled === 0) {
+        logger.warn("No caches enabled despite backend being available", {
+            backend,
+        });
+        return status;
+    }
+    logger.info("Initialization complete", {
+        backend,
+        enabled,
+        transform: status.transformCache,
+        ssrModule: status.ssrModuleCache,
+        file: status.fileCache,
+        projectCSS: status.projectCSSCache,
+        httpModule: status.httpModuleCache,
+    });
+    return status;
+}
+export function __runDistributedCacheInitializationForTests(backend, initializers) {
+    return initializeDistributedCachesWithInitializers(backend, initializers);
+}
 export function initializeDistributedCaches() {
     const backend = determineBackend();
     if (backend === "memory") {
@@ -29,58 +97,8 @@ export function initializeDistributedCaches() {
             ssrModuleCache: false,
             fileCache: false,
             projectCSSCache: false,
+            httpModuleCache: false,
         });
     }
-    return withSpan(SpanNames.CACHE_DISTRIBUTED_INIT, async () => {
-        logger.info("Initializing caches...", { backend });
-        const cacheNames = [
-            "transformCache",
-            "ssrModuleCache",
-            "fileCache",
-            "projectCSSCache",
-        ];
-        const results = await Promise.allSettled([
-            initializeTransformCache(),
-            initializeSSRDistributedCache(),
-            initializeFileCacheBackend(),
-            initializeProjectCSSCache(),
-        ]);
-        for (let i = 0; i < results.length; i++) {
-            const result = results[i];
-            if (result && result.status === "rejected") {
-                logger.error(`Cache initialization failed: ${cacheNames[i]}`, {
-                    backend,
-                    error: result.reason instanceof Error ? result.reason.message : String(result.reason),
-                });
-            }
-        }
-        const status = {
-            backend,
-            transformCache: wasSuccessful(results[0]),
-            ssrModuleCache: wasSuccessful(results[1]),
-            fileCache: wasSuccessful(results[2]),
-            projectCSSCache: wasSuccessful(results[3]),
-        };
-        const enabled = [
-            status.transformCache,
-            status.ssrModuleCache,
-            status.fileCache,
-            status.projectCSSCache,
-        ].filter(Boolean).length;
-        if (enabled === 0) {
-            logger.warn("No caches enabled despite backend being available", {
-                backend,
-            });
-            return status;
-        }
-        logger.info("Initialization complete", {
-            backend,
-            enabled,
-            transform: status.transformCache,
-            ssrModule: status.ssrModuleCache,
-            file: status.fileCache,
-            projectCSS: status.projectCSSCache,
-        });
-        return status;
-    }, { "cache.backend": backend });
+    return withSpan(SpanNames.CACHE_DISTRIBUTED_INIT, () => initializeDistributedCachesWithInitializers(backend, defaultInitializers), { "cache.backend": backend });
 }

package/esm/src/cache/module-cache.d.ts

@@ -2,6 +2,10 @@
  * Pod-Level Module Cache Singleton
  **************************/
 import { LRUCache } from "../utils/lru-wrapper.js";
+export interface ModuleCacheMap extends Map<string, string> {
+    getOrInsert(key: string, value: string): string;
+    getOrInsertComputed(key: string, callback: (key: string) => string): string;
+}
 interface ModuleCacheStats {
     moduleCache: {
         size: number;
@@ -16,8 +20,8 @@ interface ModuleCacheStats {
 }
 export declare function getModuleCache(): LRUCache<string, string>;
 export declare function getEsmCache(): LRUCache<string, string>;
-export declare function createModuleCache(): Map<string, string>;
-export declare function createEsmCache(): Map<string, string>;
+export declare function createModuleCache(): ModuleCacheMap;
+export declare function createEsmCache(): ModuleCacheMap;
 export declare function getModuleCacheStats(): ModuleCacheStats;
 export declare function clearModuleCaches(): void;
 export declare function clearModuleCacheForProject(projectId: string): number;

package/esm/src/cache/module-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-cache.d.ts","sourceRoot":"","sources":["../../../src/src/cache/module-cache.ts"],"names":[],"mappings":"AAAA;;4BAE4B;AAE5B,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAenD,UAAU,gBAAgB;IACxB,WAAW,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;CACH;AAqDD,wBAAgB,cAAc,IAAI,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAEzD;AAED,wBAAgB,WAAW,IAAI,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAEtD;AAED,wBAAgB,iBAAiB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvD;AAED,wBAAgB,cAAc,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAEpD;AA6DD,wBAAgB,mBAAmB,IAAI,gBAAgB,CAatD;AAED,wBAAgB,iBAAiB,IAAI,IAAI,CAIxC;AAED,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAgBpE;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAM1C"}
+{"version":3,"file":"module-cache.d.ts","sourceRoot":"","sources":["../../../src/src/cache/module-cache.ts"],"names":[],"mappings":"AAAA;;4BAE4B;AAE5B,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAenD,MAAM,WAAW,cAAe,SAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IACzD,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAChD,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAAC;CAC7E;AAED,UAAU,gBAAgB;IACxB,WAAW,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;CACH;AAqDD,wBAAgB,cAAc,IAAI,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAEzD;AAED,wBAAgB,WAAW,IAAI,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAEtD;AAED,wBAAgB,iBAAiB,IAAI,cAAc,CAElD;AAED,wBAAgB,cAAc,IAAI,cAAc,CAE/C;AA8FD,wBAAgB,mBAAmB,IAAI,gBAAgB,CAatD;AAED,wBAAgB,iBAAiB,IAAI,IAAI,CAIxC;AAED,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAgBpE;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAM1C"}

package/esm/src/cache/module-cache.js

@@ -57,64 +57,81 @@ export function createEsmCache() {
     return createMapInterface(getEsmCache());
 }
 function createMapInterface(cache) {
-    const map = {
-        get(key) {
-            return cache.get(key);
-        },
-        set(key, value) {
-            cache.set(key, value);
-            return map;
-        },
-        has(key) {
-            return cache.has(key);
-        },
-        delete(key) {
-            return cache.delete(key);
-        },
-        clear() {
-            cache.clear();
-        },
-        get size() {
-            return cache.size;
-        },
-        keys() {
-            return cache.keys();
-        },
-        values() {
-            const keysIter = cache.keys();
-            const cacheRef = cache;
-            return (function* () {
-                for (const key of keysIter) {
-                    const value = cacheRef.get(key);
-                    if (value !== undefined)
-                        yield value;
-                }
-            })();
-        },
-        entries() {
-            const keysIter = cache.keys();
-            const cacheRef = cache;
-            return (function* () {
-                for (const key of keysIter) {
-                    const value = cacheRef.get(key);
-                    if (value !== undefined)
-                        yield [key, value];
-                }
-            })();
-        },
-        forEach(callback) {
-            for (const key of cache.keys()) {
-                const value = cache.get(key);
+    return new LRUBackedMap(cache);
+}
+class LRUBackedMap {
+    cache;
+    [Symbol.toStringTag] = "Map";
+    constructor(cache) {
+        this.cache = cache;
+    }
+    get(key) {
+        return this.cache.get(key);
+    }
+    set(key, value) {
+        this.cache.set(key, value);
+        return this;
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    getOrInsert(key, value) {
+        const existing = this.cache.get(key);
+        if (existing !== undefined)
+            return existing;
+        this.cache.set(key, value);
+        return value;
+    }
+    getOrInsertComputed(key, callback) {
+        const existing = this.cache.get(key);
+        if (existing !== undefined)
+            return existing;
+        const value = callback(key);
+        this.cache.set(key, value);
+        return value;
+    }
+    get size() {
+        return this.cache.size;
+    }
+    keys() {
+        return this.cache.keys();
+    }
+    values() {
+        const keysIter = this.cache.keys();
+        const cacheRef = this.cache;
+        return (function* () {
+            for (const key of keysIter) {
+                const value = cacheRef.get(key);
                 if (value !== undefined)
-                    callback(value, key, map);
+                    yield value;
             }
-        },
-        [Symbol.iterator]() {
-            return map.entries();
-        },
-        [Symbol.toStringTag]: "Map",
-    };
-    return map;
+        })();
+    }
+    entries() {
+        const keysIter = this.cache.keys();
+        const cacheRef = this.cache;
+        return (function* () {
+            for (const key of keysIter) {
+                const value = cacheRef.get(key);
+                if (value !== undefined)
+                    yield [key, value];
+            }
+        })();
+    }
+    forEach(callback, thisArg) {
+        for (const [key, value] of this.entries()) {
+            callback.call(thisArg, value, key, this);
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
 }
 export function getModuleCacheStats() {
     return {

package/esm/src/transforms/esm/http-cache-wrapper.d.ts

@@ -10,8 +10,11 @@
  *
  * @module transforms/esm/http-cache-wrapper
  */
+import type { CacheBackend } from "../../cache/types.js";
 import type { BundleHash, LocalModuleCode, NormalizedUrl, PortableModuleCode } from "./http-cache-types.js";
 import { asBundleHash } from "./http-cache-invariants.js";
+export declare function __setDistributedCacheAccessorForTests(accessor: (() => Promise<CacheBackend | null>) | null): void;
+export declare function initializeHttpModuleDistributedCache(): Promise<boolean>;
 /**
  * Tokenize local code paths to portable format.
  * Replaces absolute cache directory paths with __VF_CACHE_DIR__ tokens.

package/esm/src/transforms/esm/http-cache-wrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-cache-wrapper.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAQH,OAAO,KAAK,EACV,UAAU,EAEV,eAAe,EACf,aAAa,EACb,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,YAAY,EAKb,MAAM,4BAA4B,CAAC;AAuBpC;;;;;;GAMG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,kBAAkB,CAoB3D;AAED;;;GAGG;AACH,iBAAS,UAAU,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,GAAG,eAAe,CAMtE;AAmCD;;GAEG;AACH,UAAU,aAAa;IACrB,wEAAwE;IACxE,IAAI,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7B,uDAAuD;IACvD,UAAU,EAAE,OAAO,CAAC;IACpB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,WAAW,GAAG,oBAAoB,GAAG,cAAc,GAAG,OAAO,CAAC;CAC5E;AAED;;;;;;;;;GASG;AACH,cAAM,eAAe;IACnB;;;;;;OAMG;IACG,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAiDtE;;;;;;OAMG;IACG,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAqCrE;;;;;;;;OAQG;IACG,OAAO,CACX,IAAI,EAAE,UAAU,GAAG,MAAM,EACzB,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,aAAa,GAAG,MAAM,EAC3B,GAAG,GAAE,MAAwC,GAC5C,OAAO,CAAC,IAAI,CAAC;IA+BhB;;;;;;OAMG;IACG,aAAa,CACjB,MAAM,EAAE,KAAK,CAAC,UAAU,GAAG,MAAM,CAAC,GACjC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IA8CxC;;;;;OAKG;IACG,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAcvE;;;;;;OAMG;IACG,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAsB7D;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;CAItC;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,iBAAwB,CAAC;AAErD;;;GAGG;AACH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"http-cache-wrapper.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EACV,UAAU,EAEV,eAAe,EACf,aAAa,EACb,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,YAAY,EAKb,MAAM,4BAA4B,CAAC;AAoBpC,wBAAgB,qCAAqC,CACnD,QAAQ,EAAE,CAAC,MAAM,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,GACpD,IAAI,CAEN;AAED,wBAAsB,oCAAoC,IAAI,OAAO,CAAC,OAAO,CAAC,CAM7E;AAWD;;;;;;GAMG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,kBAAkB,CAoB3D;AAED;;;GAGG;AACH,iBAAS,UAAU,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,GAAG,eAAe,CAMtE;AAmCD;;GAEG;AACH,UAAU,aAAa;IACrB,wEAAwE;IACxE,IAAI,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7B,uDAAuD;IACvD,UAAU,EAAE,OAAO,CAAC;IACpB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,WAAW,GAAG,oBAAoB,GAAG,cAAc,GAAG,OAAO,CAAC;CAC5E;AAED;;;;;;;;;GASG;AACH,cAAM,eAAe;IACnB;;;;;;OAMG;IACG,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAiDtE;;;;;;OAMG;IACG,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAqCrE;;;;;;;;OAQG;IACG,OAAO,CACX,IAAI,EAAE,UAAU,GAAG,MAAM,EACzB,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,aAAa,GAAG,MAAM,EAC3B,GAAG,GAAE,MAAwC,GAC5C,OAAO,CAAC,IAAI,CAAC;IA+BhB;;;;;;OAMG;IACG,aAAa,CACjB,MAAM,EAAE,KAAK,CAAC,UAAU,GAAG,MAAM,CAAC,GACjC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IA8CxC;;;;;OAKG;IACG,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAcvE;;;;;;OAMG;IACG,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAsB7D;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;CAItC;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,iBAAwB,CAAC;AAErD;;;GAGG;AACH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC"}

package/esm/src/transforms/esm/http-cache-wrapper.js

@@ -23,6 +23,20 @@ const logger = rendererLogger.component("http-cache-wrapper");
 const BATCH_FETCH_CHUNK_SIZE = 100;
 /** Lazy-loaded distributed cache backend for cross-pod sharing */
 const getDistributedCache = createDistributedCacheAccessor(() => CacheBackends.httpModule(), "HTTP-CACHE-WRAPPER");
+let testDistributedCacheAccessor = null;
+function resolveDistributedCache() {
+    return testDistributedCacheAccessor ? testDistributedCacheAccessor() : getDistributedCache();
+}
+export function __setDistributedCacheAccessorForTests(accessor) {
+    testDistributedCacheAccessor = accessor;
+}
+export async function initializeHttpModuleDistributedCache() {
+    const distributed = await resolveDistributedCache();
+    if (!distributed)
+        return false;
+    logger.info("Initialized distributed cache backend", { backend: distributed.type });
+    return true;
+}
 /**
  * Generate versioned cache key for HTTP bundles.
  * Format: {VERSION}:{prefix}:{hash}
@@ -110,7 +124,7 @@ class HttpBundleCache {
      * @returns Result containing local code or failure reason
      */
     async getCodeByHash(hash) {
-        const distributed = await getDistributedCache();
+        const distributed = await resolveDistributedCache();
         if (!distributed) {
             return { code: null, wasGzipped: false, failReason: "not_found" };
         }
@@ -160,7 +174,7 @@ class HttpBundleCache {
      * @returns Result containing local code or failure reason
      */
     async getCodeByUrl(hash) {
-        const distributed = await getDistributedCache();
+        const distributed = await resolveDistributedCache();
         if (!distributed) {
             return { code: null, wasGzipped: false, failReason: "not_found" };
         }
@@ -200,7 +214,7 @@ class HttpBundleCache {
      * @param ttl - TTL in seconds (defaults to HTTP_MODULE_DISTRIBUTED_TTL_SEC)
      */
     async setCode(hash, code, url, ttl = HTTP_MODULE_DISTRIBUTED_TTL_SEC) {
-        const distributed = await getDistributedCache();
+        const distributed = await resolveDistributedCache();
         if (!distributed)
             return;
         const hashStr = typeof hash === "string" ? hash : hash;
@@ -233,7 +247,7 @@ class HttpBundleCache {
      * @returns Map of hash -> local code (missing/failed hashes not included)
      */
     async getBatchCodes(hashes) {
-        const distributed = await getDistributedCache();
+        const distributed = await resolveDistributedCache();
         if (!distributed)
             return new Map();
         const results = new Map();
@@ -278,7 +292,7 @@ class HttpBundleCache {
      * @returns Original URL or null
      */
     async getOriginalUrl(hash) {
-        const distributed = await getDistributedCache();
+        const distributed = await resolveDistributedCache();
         if (!distributed)
             return null;
         const hashStr = typeof hash === "string" ? hash : hash;
@@ -298,7 +312,7 @@ class HttpBundleCache {
      * @returns true if deletion was attempted, false if cache unavailable
      */
     async deleteCode(hash) {
-        const distributed = await getDistributedCache();
+        const distributed = await resolveDistributedCache();
         if (!distributed)
             return false;
         const hashStr = typeof hash === "string" ? hash : hash;
@@ -321,7 +335,7 @@ class HttpBundleCache {
      * Check if distributed cache is available.
      */
     async isAvailable() {
-        const distributed = await getDistributedCache();
+        const distributed = await resolveDistributedCache();
         return distributed !== null;
     }
 }

package/esm/src/utils/version.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.1.87";
+export declare const VERSION = "0.1.88";
 export declare const SERVER_START_TIME: number;
 export interface BuildVersion {
     framework: string;

package/esm/src/utils/version.js

@@ -1,6 +1,6 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.87";
+export const VERSION = "0.1.88";
 export const SERVER_START_TIME = Date.now();
 export function createBuildVersion(projectUpdatedAt) {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.87",
+  "version": "0.1.88",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.87",
+  "version": "0.1.88",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [

package/src/src/cache/distributed-cache-init.ts

@@ -1,6 +1,7 @@
 import { initializeFileCacheBackend } from "../platform/adapters/fs/cache/file-cache.js";
 import { initializeSSRDistributedCache } from "../modules/react-loader/ssr-module-loader/index.js";
 import { initializeTransformCache } from "../transforms/esm/transform-cache.js";
+import { initializeHttpModuleDistributedCache } from "../transforms/esm/http-cache-wrapper.js";
 import { SpanNames } from "../observability/tracing/span-names.js";
 import { withSpan } from "../observability/tracing/otlp-setup.js";
 import { initializeProjectCSSCache } from "../html/styles-builder/tailwind-compiler.js";
@@ -16,8 +17,25 @@ interface DistributedCacheStatus {
   ssrModuleCache: boolean;
   fileCache: boolean;
   projectCSSCache: boolean;
+  httpModuleCache: boolean;
 }
 
+type DistributedCacheInitializers = {
+  transformCache: () => Promise<boolean>;
+  ssrModuleCache: () => Promise<boolean>;
+  fileCache: () => Promise<boolean>;
+  projectCSSCache: () => Promise<boolean>;
+  httpModuleCache: () => Promise<boolean>;
+};
+
+const defaultInitializers: DistributedCacheInitializers = {
+  transformCache: initializeTransformCache,
+  ssrModuleCache: initializeSSRDistributedCache,
+  fileCache: initializeFileCacheBackend,
+  projectCSSCache: initializeProjectCSSCache,
+  httpModuleCache: initializeHttpModuleDistributedCache,
+};
+
 function determineBackend(): DistributedCacheStatus["backend"] {
   if (isApiCacheAvailable()) return "api";
   if (isRedisConfigured()) return "redis";
@@ -29,6 +47,81 @@ function wasSuccessful(result: PromiseSettledResult<boolean>): boolean {
   return result.status === "fulfilled" && result.value;
 }
 
+async function initializeDistributedCachesWithInitializers(
+  backend: DistributedCacheStatus["backend"],
+  initializers: DistributedCacheInitializers,
+): Promise<DistributedCacheStatus> {
+  logger.info("Initializing caches...", { backend });
+
+  const cacheNames = [
+    "transformCache",
+    "ssrModuleCache",
+    "fileCache",
+    "projectCSSCache",
+    "httpModuleCache",
+  ] as const;
+  const results = await Promise.allSettled([
+    initializers.transformCache(),
+    initializers.ssrModuleCache(),
+    initializers.fileCache(),
+    initializers.projectCSSCache(),
+    initializers.httpModuleCache(),
+  ]);
+
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result && result.status === "rejected") {
+      logger.error(`Cache initialization failed: ${cacheNames[i]}`, {
+        backend,
+        error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+      });
+    }
+  }
+
+  const status: DistributedCacheStatus = {
+    backend,
+    transformCache: wasSuccessful(results[0]),
+    ssrModuleCache: wasSuccessful(results[1]),
+    fileCache: wasSuccessful(results[2]),
+    projectCSSCache: wasSuccessful(results[3]),
+    httpModuleCache: wasSuccessful(results[4]),
+  };
+
+  const enabled = [
+    status.transformCache,
+    status.ssrModuleCache,
+    status.fileCache,
+    status.projectCSSCache,
+    status.httpModuleCache,
+  ].filter(Boolean).length;
+
+  if (enabled === 0) {
+    logger.warn("No caches enabled despite backend being available", {
+      backend,
+    });
+    return status;
+  }
+
+  logger.info("Initialization complete", {
+    backend,
+    enabled,
+    transform: status.transformCache,
+    ssrModule: status.ssrModuleCache,
+    file: status.fileCache,
+    projectCSS: status.projectCSSCache,
+    httpModule: status.httpModuleCache,
+  });
+
+  return status;
+}
+
+export function __runDistributedCacheInitializationForTests(
+  backend: DistributedCacheStatus["backend"],
+  initializers: DistributedCacheInitializers,
+): Promise<DistributedCacheStatus> {
+  return initializeDistributedCachesWithInitializers(backend, initializers);
+}
+
 export function initializeDistributedCaches(): Promise<DistributedCacheStatus> {
   const backend = determineBackend();
 
@@ -39,70 +132,13 @@ export function initializeDistributedCaches(): Promise<DistributedCacheStatus> {
       ssrModuleCache: false,
       fileCache: false,
       projectCSSCache: false,
+      httpModuleCache: false,
     });
   }
 
   return withSpan(
     SpanNames.CACHE_DISTRIBUTED_INIT,
-    async (): Promise<DistributedCacheStatus> => {
-      logger.info("Initializing caches...", { backend });
-
-      const cacheNames = [
-        "transformCache",
-        "ssrModuleCache",
-        "fileCache",
-        "projectCSSCache",
-      ] as const;
-      const results = await Promise.allSettled([
-        initializeTransformCache(),
-        initializeSSRDistributedCache(),
-        initializeFileCacheBackend(),
-        initializeProjectCSSCache(),
-      ]);
-
-      for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-        if (result && result.status === "rejected") {
-          logger.error(`Cache initialization failed: ${cacheNames[i]}`, {
-            backend,
-            error: result.reason instanceof Error ? result.reason.message : String(result.reason),
-          });
-        }
-      }
-
-      const status: DistributedCacheStatus = {
-        backend,
-        transformCache: wasSuccessful(results[0]),
-        ssrModuleCache: wasSuccessful(results[1]),
-        fileCache: wasSuccessful(results[2]),
-        projectCSSCache: wasSuccessful(results[3]),
-      };
-
-      const enabled = [
-        status.transformCache,
-        status.ssrModuleCache,
-        status.fileCache,
-        status.projectCSSCache,
-      ].filter(Boolean).length;
-
-      if (enabled === 0) {
-        logger.warn("No caches enabled despite backend being available", {
-          backend,
-        });
-        return status;
-      }
-
-      logger.info("Initialization complete", {
-        backend,
-        enabled,
-        transform: status.transformCache,
-        ssrModule: status.ssrModuleCache,
-        file: status.fileCache,
-        projectCSS: status.projectCSSCache,
-      });
-
-      return status;
-    },
+    () => initializeDistributedCachesWithInitializers(backend, defaultInitializers),
     { "cache.backend": backend },
   );
 }

package/src/src/cache/module-cache.ts

@@ -17,6 +17,11 @@ const logger = rendererLogger.component("module-cache");
 let moduleCache: LRUCache<string, string> | null = null;
 let esmCache: LRUCache<string, string> | null = null;
 
+export interface ModuleCacheMap extends Map<string, string> {
+  getOrInsert(key: string, value: string): string;
+  getOrInsertComputed(key: string, callback: (key: string) => string): string;
+}
+
 interface ModuleCacheStats {
   moduleCache: {
     size: number;
@@ -89,71 +94,104 @@ export function getEsmCache(): LRUCache<string, string> {
   return getOrInitPodCache(esmPodCacheOptions);
 }
 
-export function createModuleCache(): Map<string, string> {
+export function createModuleCache(): ModuleCacheMap {
   return createMapInterface(getModuleCache());
 }
 
-export function createEsmCache(): Map<string, string> {
+export function createEsmCache(): ModuleCacheMap {
   return createMapInterface(getEsmCache());
 }
 
-function createMapInterface(cache: LRUCache<string, string>): Map<string, string> {
-  const map: Map<string, string> = {
-    get(key: string): string | undefined {
-      return cache.get(key);
-    },
-    set(key: string, value: string): Map<string, string> {
-      cache.set(key, value);
-      return map;
-    },
-    has(key: string): boolean {
-      return cache.has(key);
-    },
-    delete(key: string): boolean {
-      return cache.delete(key);
-    },
-    clear(): void {
-      cache.clear();
-    },
-    get size(): number {
-      return cache.size;
-    },
-    keys(): MapIterator<string> {
-      return cache.keys() as unknown as MapIterator<string>;
-    },
-    values(): MapIterator<string> {
-      const keysIter = cache.keys();
-      const cacheRef = cache;
-      return (function* () {
-        for (const key of keysIter) {
-          const value = cacheRef.get(key);
-          if (value !== undefined) yield value;
-        }
-      })() as unknown as MapIterator<string>;
-    },
-    entries(): MapIterator<[string, string]> {
-      const keysIter = cache.keys();
-      const cacheRef = cache;
-      return (function* () {
-        for (const key of keysIter) {
-          const value = cacheRef.get(key);
-          if (value !== undefined) yield [key, value] as [string, string];
-        }
-      })() as unknown as MapIterator<[string, string]>;
-    },
-    forEach(callback: (value: string, key: string, map: Map<string, string>) => void): void {
-      for (const key of cache.keys()) {
-        const value = cache.get(key);
-        if (value !== undefined) callback(value, key, map);
+function createMapInterface(cache: LRUCache<string, string>): ModuleCacheMap {
+  return new LRUBackedMap(cache);
+}
+
+class LRUBackedMap implements ModuleCacheMap {
+  readonly [Symbol.toStringTag] = "Map";
+
+  constructor(private readonly cache: LRUCache<string, string>) {
+  }
+
+  get(key: string): string | undefined {
+    return this.cache.get(key);
+  }
+
+  set(key: string, value: string): this {
+    this.cache.set(key, value);
+    return this;
+  }
+
+  has(key: string): boolean {
+    return this.cache.has(key);
+  }
+
+  delete(key: string): boolean {
+    return this.cache.delete(key);
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  getOrInsert(key: string, value: string): string {
+    const existing = this.cache.get(key);
+    if (existing !== undefined) return existing;
+
+    this.cache.set(key, value);
+    return value;
+  }
+
+  getOrInsertComputed(key: string, callback: (key: string) => string): string {
+    const existing = this.cache.get(key);
+    if (existing !== undefined) return existing;
+
+    const value = callback(key);
+    this.cache.set(key, value);
+    return value;
+  }
+
+  get size(): number {
+    return this.cache.size;
+  }
+
+  keys(): MapIterator<string> {
+    return this.cache.keys() as unknown as MapIterator<string>;
+  }
+
+  values(): MapIterator<string> {
+    const keysIter = this.cache.keys();
+    const cacheRef = this.cache;
+    return (function* () {
+      for (const key of keysIter) {
+        const value = cacheRef.get(key);
+        if (value !== undefined) yield value;
       }
-    },
-    [Symbol.iterator](): MapIterator<[string, string]> {
-      return map.entries();
-    },
-    [Symbol.toStringTag]: "Map",
-  };
+    })() as unknown as MapIterator<string>;
+  }
 
-  return map;
+  entries(): MapIterator<[string, string]> {
+    const keysIter = this.cache.keys();
+    const cacheRef = this.cache;
+    return (function* () {
+      for (const key of keysIter) {
+        const value = cacheRef.get(key);
+        if (value !== undefined) yield [key, value] as [string, string];
+      }
+    })() as unknown as MapIterator<[string, string]>;
+  }
+
+  forEach(
+    callback: (value: string, key: string, map: Map<string, string>) => void,
+    thisArg?: unknown,
+  ): void {
+    for (const [key, value] of this.entries()) {
+      callback.call(thisArg, value, key, this);
+    }
+  }
+
+  [Symbol.iterator](): MapIterator<[string, string]> {
+    return this.entries();
+  }
 }
 
 export function getModuleCacheStats(): ModuleCacheStats {

package/src/src/transforms/esm/http-cache-wrapper.ts

@@ -16,6 +16,7 @@ import { rendererLogger } from "../../utils/index.js";
 import { VERSION } from "../../utils/version.js";
 import { getCacheBaseDir } from "../../utils/cache-dir.js";
 import { CacheBackends, createDistributedCacheAccessor } from "../../cache/backend.js";
+import type { CacheBackend } from "../../cache/types.js";
 import { HTTP_MODULE_DISTRIBUTED_TTL_SEC } from "../../utils/constants/cache.js";
 import type {
   BundleHash,
@@ -44,6 +45,26 @@ const getDistributedCache = createDistributedCacheAccessor(
   "HTTP-CACHE-WRAPPER",
 );
 
+let testDistributedCacheAccessor: (() => Promise<CacheBackend | null>) | null = null;
+
+function resolveDistributedCache(): Promise<CacheBackend | null> {
+  return testDistributedCacheAccessor ? testDistributedCacheAccessor() : getDistributedCache();
+}
+
+export function __setDistributedCacheAccessorForTests(
+  accessor: (() => Promise<CacheBackend | null>) | null,
+): void {
+  testDistributedCacheAccessor = accessor;
+}
+
+export async function initializeHttpModuleDistributedCache(): Promise<boolean> {
+  const distributed = await resolveDistributedCache();
+  if (!distributed) return false;
+
+  logger.info("Initialized distributed cache backend", { backend: distributed.type });
+  return true;
+}
+
 /**
  * Generate versioned cache key for HTTP bundles.
  * Format: {VERSION}:{prefix}:{hash}
@@ -158,7 +179,7 @@ class HttpBundleCache {
    * @returns Result containing local code or failure reason
    */
   async getCodeByHash(hash: BundleHash | string): Promise<GetCodeResult> {
-    const distributed = await getDistributedCache();
+    const distributed = await resolveDistributedCache();
     if (!distributed) {
       return { code: null, wasGzipped: false, failReason: "not_found" };
     }
@@ -214,7 +235,7 @@ class HttpBundleCache {
    * @returns Result containing local code or failure reason
    */
   async getCodeByUrl(hash: BundleHash | string): Promise<GetCodeResult> {
-    const distributed = await getDistributedCache();
+    const distributed = await resolveDistributedCache();
     if (!distributed) {
       return { code: null, wasGzipped: false, failReason: "not_found" };
     }
@@ -265,7 +286,7 @@ class HttpBundleCache {
     url: NormalizedUrl | string,
     ttl: number = HTTP_MODULE_DISTRIBUTED_TTL_SEC,
   ): Promise<void> {
-    const distributed = await getDistributedCache();
+    const distributed = await resolveDistributedCache();
     if (!distributed) return;
 
     const hashStr = typeof hash === "string" ? hash : (hash as unknown as string);
@@ -305,7 +326,7 @@ class HttpBundleCache {
   async getBatchCodes(
     hashes: Array<BundleHash | string>,
   ): Promise<Map<string, LocalModuleCode>> {
-    const distributed = await getDistributedCache();
+    const distributed = await resolveDistributedCache();
     if (!distributed) return new Map();
 
     const results = new Map<string, LocalModuleCode>();
@@ -357,7 +378,7 @@ class HttpBundleCache {
    * @returns Original URL or null
    */
   async getOriginalUrl(hash: BundleHash | string): Promise<string | null> {
-    const distributed = await getDistributedCache();
+    const distributed = await resolveDistributedCache();
     if (!distributed) return null;
 
     const hashStr = typeof hash === "string" ? hash : (hash as unknown as string);
@@ -378,7 +399,7 @@ class HttpBundleCache {
    * @returns true if deletion was attempted, false if cache unavailable
    */
   async deleteCode(hash: BundleHash | string): Promise<boolean> {
-    const distributed = await getDistributedCache();
+    const distributed = await resolveDistributedCache();
     if (!distributed) return false;
 
     const hashStr = typeof hash === "string" ? hash : (hash as unknown as string);
@@ -403,7 +424,7 @@ class HttpBundleCache {
    * Check if distributed cache is available.
    */
   async isAvailable(): Promise<boolean> {
-    const distributed = await getDistributedCache();
+    const distributed = await resolveDistributedCache();
     return distributed !== null;
   }
 }

package/src/src/utils/version.ts

@@ -1,6 +1,6 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.87";
+export const VERSION = "0.1.88";
 
 export const SERVER_START_TIME: number = Date.now();