veryfront 0.0.81 → 0.0.83

package/esm/src/cli/index/start-handler.js

@@ -0,0 +1,145 @@
+import { cwd, getEnv } from "../../platform/compat/process.js";
+import { createFileSystem } from "../../platform/compat/fs.js";
+import { isAbsolute, join, resolve } from "../../platform/compat/path/index.js";
+import { cliLogger } from "../../utils/index.js";
+import { exitProcess, registerTerminationSignals } from "../utils/index.js";
+const DEFAULT_START_PORT = 8080;
+const DEFAULT_MCP_PORT = 9999;
+function getProjectSlug(path) {
+    return path.replace(/\/+$/, "").split("/").pop() || "";
+}
+async function isVeryFrontProject(projectPath) {
+    const fs = createFileSystem();
+    const markers = ["app", "pages", "components"];
+    const checks = await Promise.all(markers.map((m) => fs.exists(join(projectPath, m))));
+    return checks.some(Boolean);
+}
+async function findProjectsInDirs(baseDirs) {
+    const projects = new Map();
+    const fs = createFileSystem();
+    for (const baseDir of baseDirs) {
+        const absoluteBase = isAbsolute(baseDir) ? baseDir : join(cwd(), baseDir);
+        if (!(await fs.exists(absoluteBase)))
+            continue;
+        try {
+            for await (const entry of fs.readDir(absoluteBase)) {
+                if (!entry.isDirectory || entry.name.startsWith("."))
+                    continue;
+                const projectPath = join(absoluteBase, entry.name);
+                if (await isVeryFrontProject(projectPath)) {
+                    projects.set(entry.name, resolve(projectPath));
+                }
+            }
+        }
+        catch {
+            // Directory not readable - skip
+        }
+    }
+    return projects;
+}
+async function discoverProjects(explicitPath) {
+    const [projects, examples] = await Promise.all([
+        findProjectsInDirs(["data/projects", "projects"]),
+        findProjectsInDirs(["examples"]),
+    ]);
+    const fs = createFileSystem();
+    let defaultProject = null;
+    // Add explicit project path if provided
+    if (explicitPath) {
+        const absolutePath = isAbsolute(explicitPath) ? explicitPath : join(cwd(), explicitPath);
+        if (await fs.exists(absolutePath)) {
+            const slug = getProjectSlug(absolutePath);
+            projects.set(slug, resolve(absolutePath));
+            defaultProject = slug;
+        }
+    }
+    // Fall back to current directory if no projects found
+    if (projects.size === 0 && !defaultProject) {
+        const currentDir = cwd();
+        if (await isVeryFrontProject(currentDir)) {
+            const slug = getProjectSlug(currentDir);
+            projects.set(slug, resolve(currentDir));
+            defaultProject = slug;
+        }
+    }
+    return { projects, examples, defaultProject };
+}
+async function trySetupProxy(localProjects) {
+    try {
+        // Proxy is only available in local dev, not in the npm package
+        const { createProxyHandler, injectContextHeaders } = await import("../../../proxy/handler.js");
+        const { createCacheFromEnv } = await import("../../../proxy/cache/index.js");
+        const proxyConfig = {
+            apiBaseUrl: getEnv("VERYFRONT_API_BASE_URL") || "http://api.lvh.me:4000",
+            clientId: getEnv("OAUTH_CLIENT_ID") || "",
+            clientSecret: getEnv("OAUTH_CLIENT_SECRET") || "",
+            previewClientId: getEnv("OAUTH_PREVIEW_CLIENT_ID") || "",
+            previewClientSecret: getEnv("OAUTH_PREVIEW_CLIENT_SECRET") || "",
+            apiToken: getEnv("VERYFRONT_API_TOKEN") || "",
+            localProjects: Object.fromEntries(localProjects),
+        };
+        const cache = await createCacheFromEnv();
+        const handler = createProxyHandler({ config: proxyConfig, cache });
+        return {
+            interceptor: async (req) => injectContextHeaders(req, await handler.processRequest(req)),
+            close: () => handler.close(),
+        };
+    }
+    catch {
+        return { interceptor: undefined, close: async () => { } };
+    }
+}
+export async function handleStartCommand(args) {
+    const port = typeof args.port === "number" ? args.port : DEFAULT_START_PORT;
+    const mcpPort = typeof args["mcp-port"] === "number" ? args["mcp-port"] : DEFAULT_MCP_PORT;
+    const projectPath = args.project ? String(args.project) : null;
+    const headless = Boolean(args.headless || args["no-tui"]);
+    const { createApp, showStartup } = await import("../app/index.js");
+    const discovered = await discoverProjects(projectPath);
+    const app = createApp({
+        port,
+        mcpPort,
+        headless,
+        projects: discovered.projects,
+        examples: discovered.examples,
+        defaultProject: discovered.defaultProject ?? undefined,
+    });
+    const restoreConsole = app.interceptConsole();
+    if (!headless) {
+        await showStartup(["Loading configuration", "Discovering projects", "Starting server"]);
+    }
+    const allProjects = new Map([...discovered.projects, ...discovered.examples]);
+    const proxy = await trySetupProxy(allProjects);
+    const { createDevServer } = await import("../../server/dev-server.js");
+    const shutdownController = new AbortController();
+    const devServer = await createDevServer({
+        port,
+        projectDir: cwd(),
+        hmrPort: port + 1,
+        enableHMR: true,
+        enableFastRefresh: true,
+        signal: shutdownController.signal,
+        requestInterceptor: proxy.interceptor,
+    });
+    await devServer.ready;
+    const { createMCPServer } = await import("../mcp/index.js");
+    const mcpServer = await createMCPServer({ httpPort: mcpPort });
+    app.setServerReady();
+    let shuttingDown = false;
+    async function shutdown() {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        restoreConsole();
+        cliLogger.info("Shutting down...");
+        app.stop();
+        await mcpServer.stop();
+        shutdownController.abort();
+        await devServer.stop();
+        await proxy.close();
+        exitProcess(0);
+    }
+    registerTerminationSignals(() => void shutdown());
+    app.start();
+    await new Promise(() => { });
+}

package/esm/src/cli/mcp/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * MCP Module for Dev Server
+ *
+ * Exposes dev server functionality via MCP (Model Context Protocol)
+ * for coding agents like Claude Code and Cursor.
+ */
+export * from "./server.js";
+export * from "./error-collector.js";
+export * from "./log-buffer.js";
+export * from "./tools.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/src/cli/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/cli/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC"}

package/esm/src/cli/mcp/index.js

@@ -0,0 +1,10 @@
+/**
+ * MCP Module for Dev Server
+ *
+ * Exposes dev server functionality via MCP (Model Context Protocol)
+ * for coding agents like Claude Code and Cursor.
+ */
+export * from "./server.js";
+export * from "./error-collector.js";
+export * from "./log-buffer.js";
+export * from "./tools.js";

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/middleware/builtin/security/redis-rate-limit.d.ts

@@ -5,10 +5,12 @@ export interface RedisRateLimitOptions {
 }
 export declare class RedisRateLimitStore implements RateLimitStore {
     private client;
+    private clientPromise;
     private readonly url?;
     private readonly keyPrefix;
     constructor(options?: RedisRateLimitOptions);
     private ensureClient;
+    private connectClient;
     private storageKey;
     increment(key: string, windowMs: number): Promise<RateLimitEntry>;
     reset(key: string): Promise<void>;

package/esm/src/middleware/builtin/security/redis-rate-limit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redis-rate-limit.d.ts","sourceRoot":"","sources":["../../../../../src/src/middleware/builtin/security/redis-rate-limit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAYjE,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,mBAAoB,YAAW,cAAc;IACxD,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,OAAO,GAAE,qBAA0B;YAKjC,YAAY;IA8B1B,OAAO,CAAC,UAAU;IAIZ,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAqBjE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}
+{"version":3,"file":"redis-rate-limit.d.ts","sourceRoot":"","sources":["../../../../../src/src/middleware/builtin/security/redis-rate-limit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAYjE,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,mBAAoB,YAAW,cAAc;IACxD,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,aAAa,CAAqC;IAC1D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,OAAO,GAAE,qBAA0B;IAK/C,OAAO,CAAC,YAAY;YAQN,aAAa;IAkC3B,OAAO,CAAC,UAAU;IAIZ,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAqBjE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}

package/esm/src/middleware/builtin/security/redis-rate-limit.js

@@ -2,15 +2,22 @@ import { createError, toError } from "../../../errors/veryfront-error.js";
 import { serverLogger as logger } from "../../../utils/index.js";
 export class RedisRateLimitStore {
     client = null;
+    clientPromise = null;
     url;
     keyPrefix;
     constructor(options = {}) {
         this.url = options.url;
         this.keyPrefix = options.keyPrefix ?? "veryfront:ratelimit:";
     }
-    async ensureClient() {
+    ensureClient() {
         if (this.client)
-            return this.client;
+            return Promise.resolve(this.client);
+        if (this.clientPromise)
+            return this.clientPromise;
+        this.clientPromise = this.connectClient();
+        return this.clientPromise;
+    }
+    async connectClient() {
         let createClient;
         try {
             const redisClientModule = ["npm:@redis/client", "@1.5.8"].join("");
@@ -18,18 +25,25 @@ export class RedisRateLimitStore {
             createClient = mod.createClient;
         }
         catch {
+            this.clientPromise = null;
             throw toError(createError({
                 type: "config",
                 message: "Redis rate limit store requires npm:@redis/client. Install dependencies or use MemoryRateLimitStore.",
             }));
         }
-        const client = createClient({ url: this.url });
-        client.on?.("error", (err) => {
-            logger.error("[redis-ratelimit] client error", err);
-        });
-        await client.connect();
-        this.client = client;
-        return client;
+        try {
+            const client = createClient({ url: this.url });
+            client.on?.("error", (err) => {
+                logger.error("[redis-ratelimit] client error", err);
+            });
+            await client.connect();
+            this.client = client;
+            return client;
+        }
+        catch (error) {
+            this.clientPromise = null;
+            throw error;
+        }
     }
     storageKey(key) {
         return `${this.keyPrefix}${key}`;

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

@@ -1,14 +1,24 @@
 /** Redis caching for cross-pod SSR module sharing */
 import { type RedisClient } from "../../../../utils/redis-client.js";
+/**
+ * @deprecated Legacy key builder. CacheBackend handles prefixing internally.
+ * Used only for backward compatibility if needed.
+ */
 export declare function redisKey(key: string): string;
 /** Initialize distributed caching for SSR modules */
 export declare function initializeSSRDistributedCache(): Promise<boolean>;
+/** Check if distributed caching is enabled for SSR modules */
 export declare function isSSRDistributedCacheEnabled(): boolean;
 /** @deprecated Use initializeSSRDistributedCache instead */
 export declare const initializeSSRRedisCache: typeof initializeSSRDistributedCache;
 /** @deprecated Use isSSRDistributedCacheEnabled instead */
 export declare const isSSRRedisCacheEnabled: typeof isSSRDistributedCacheEnabled;
+/** @deprecated Use isSSRDistributedCacheEnabled instead */
 export declare function getRedisEnabled(): boolean;
+/**
+ * @deprecated Direct Redis client access is deprecated. Use CacheBackend abstraction.
+ * Returns null to force use of CacheBackend path in updated consumers.
+ */
 export declare function getRedisClientInstance(): RedisClient | null;
 export declare function getFromRedis(cacheKey: string): Promise<string | null>;
 /** Store transformed code in Redis with environment-aware TTL */

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

@@ -1 +1 @@
-{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../../../src/src/modules/react-loader/ssr-module-loader/cache/redis.ts"],"names":[],"mappings":"AAAA,qDAAqD;AAGrD,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,mCAAmC,CAAC;AAS3C,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,qDAAqD;AACrD,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,OAAO,CAAC,CA+BtE;AAED,wBAAgB,4BAA4B,IAAI,OAAO,CAEtD;AAED,4DAA4D;AAC5D,eAAO,MAAM,uBAAuB,sCAAgC,CAAC;AAErE,2DAA2D;AAC3D,eAAO,MAAM,sBAAsB,qCAA+B,CAAC;AAEnE,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED,wBAAgB,sBAAsB,IAAI,WAAW,GAAG,IAAI,CAE3D;AAED,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAS3E;AAED,iEAAiE;AACjE,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACxD,OAAO,CAAC,IAAI,CAAC,CAUf"}
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../../../src/src/modules/react-loader/ssr-module-loader/cache/redis.ts"],"names":[],"mappings":"AAAA,qDAAqD;AAGrD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAWrE;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,qDAAqD;AACrD,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,OAAO,CAAC,CAGtE;AAED,8DAA8D;AAC9D,wBAAgB,4BAA4B,IAAI,OAAO,CAMtD;AAED,4DAA4D;AAC5D,eAAO,MAAM,uBAAuB,sCAAgC,CAAC;AAErE,2DAA2D;AAC3D,eAAO,MAAM,sBAAsB,qCAA+B,CAAC;AAEnE,2DAA2D;AAC3D,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,WAAW,GAAG,IAAI,CAE3D;AAED,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAU3E;AAED,iEAAiE;AACjE,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACxD,OAAO,CAAC,IAAI,CAAC,CAWf"}

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

@@ -1,79 +1,67 @@
 /** Redis caching for cross-pod SSR module sharing */
 import { rendererLogger as logger } from "../../../../utils/index.js";
-import { getRedisClient, isRedisConfigured, } from "../../../../utils/redis-client.js";
 import { buildRedisSSRModuleKey } from "../../../../cache/index.js";
 import { getSSRModuleRedisTTL } from "../constants.js";
-let redisEnabled = false;
-let redisClient = null;
-let redisInitialized = false;
-let redisInitPromise = null;
+import { CacheBackends, createDistributedCacheAccessor } from "../../../../cache/backend.js";
+/** Lazy-loaded distributed cache backend for cross-pod sharing */
+const getDistributedCache = createDistributedCacheAccessor(() => CacheBackends.ssrModule(), "SSR-MODULE-LOADER");
+/**
+ * @deprecated Legacy key builder. CacheBackend handles prefixing internally.
+ * Used only for backward compatibility if needed.
+ */
 export function redisKey(key) {
     return buildRedisSSRModuleKey(key);
 }
 /** Initialize distributed caching for SSR modules */
 export async function initializeSSRDistributedCache() {
-    if (redisInitialized)
-        return redisEnabled;
-    if (redisInitPromise) {
-        await redisInitPromise;
-        return redisEnabled;
-    }
-    redisInitPromise = (async () => {
-        if (!isRedisConfigured()) {
-            logger.debug("[SSR-MODULE-LOADER] Redis not configured, using memory cache");
-            redisInitialized = true;
-            return;
-        }
-        try {
-            redisClient = await getRedisClient();
-            redisEnabled = true;
-            logger.debug("[SSR-MODULE-LOADER] Redis cache enabled");
-        }
-        catch (error) {
-            logger.warn("[SSR-MODULE-LOADER] Redis unavailable, falling back to memory cache", { error });
-            redisEnabled = false;
-        }
-        finally {
-            redisInitialized = true;
-        }
-    })();
-    await redisInitPromise;
-    redisInitPromise = null;
-    return redisEnabled;
+    const backend = await getDistributedCache();
+    return backend !== null;
 }
+/** Check if distributed caching is enabled for SSR modules */
 export function isSSRDistributedCacheEnabled() {
-    return redisEnabled && redisClient !== null;
+    // We can't synchronously check if backend is initialized without accessing the promise
+    // But we can check if we *should* be enabled based on env via CacheBackend utils
+    // For now, this returns true because it's used as a guard for get/set calls
+    // which themselves are async and handle missing backends gracefully.
+    return true;
 }
 /** @deprecated Use initializeSSRDistributedCache instead */
 export const initializeSSRRedisCache = initializeSSRDistributedCache;
 /** @deprecated Use isSSRDistributedCacheEnabled instead */
 export const isSSRRedisCacheEnabled = isSSRDistributedCacheEnabled;
+/** @deprecated Use isSSRDistributedCacheEnabled instead */
 export function getRedisEnabled() {
-    return redisEnabled;
+    return isSSRDistributedCacheEnabled();
 }
+/**
+ * @deprecated Direct Redis client access is deprecated. Use CacheBackend abstraction.
+ * Returns null to force use of CacheBackend path in updated consumers.
+ */
 export function getRedisClientInstance() {
-    return redisClient;
+    return null;
 }
 export async function getFromRedis(cacheKey) {
-    if (!redisEnabled || !redisClient)
+    const backend = await getDistributedCache();
+    if (!backend)
         return null;
     try {
-        return await redisClient.get(redisKey(cacheKey));
+        return await backend.get(cacheKey);
     }
     catch (error) {
-        logger.debug("[SSR-MODULE-LOADER] Redis get failed", { key: cacheKey, error });
+        logger.debug("[SSR-MODULE-LOADER] Distributed cache get failed", { key: cacheKey, error });
         return null;
     }
 }
 /** Store transformed code in Redis with environment-aware TTL */
 export async function setInRedis(cacheKey, code, options) {
-    if (!redisEnabled || !redisClient)
+    const backend = await getDistributedCache();
+    if (!backend)
         return;
     const ttl = options?.ttlSeconds ?? getSSRModuleRedisTTL(options?.isProduction ?? true);
     try {
-        await redisClient.set(redisKey(cacheKey), code, { EX: ttl });
+        await backend.set(cacheKey, code, ttl);
     }
     catch (error) {
-        logger.debug("[SSR-MODULE-LOADER] Redis set failed", { key: cacheKey, error });
+        logger.debug("[SSR-MODULE-LOADER] Distributed cache set failed", { key: cacheKey, error });
     }
 }

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;AAsCpC,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAgC3E;;;;;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;IA6RzC;;;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

@@ -21,8 +21,34 @@ import { SpanNames } from "../../../observability/tracing/span-names.js";
 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 { failedComponents, getFromRedis, globalCrossProjectCache, globalInProgress, globalModuleCache, globalTmpDirs, isSSRDistributedCacheEnabled, setInRedis, transformSemaphore, } from "./cache/index.js";
+import { getCacheBaseDir, getHttpBundleCacheDir } from "../../../utils/cache-dir.js";
+import { ensureHttpBundlesExist } from "../../../transforms/esm/http-cache.js";
+import { LRUCache } from "../../../utils/lru-wrapper.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 modules whose HTTP bundles have been verified, keyed by tempPath:contentHash.
+ * Bounded LRU to prevent unbounded memory growth in long-running pods.
+ * Keying by contentHash ensures verification is re-done when content changes at the same path.
+ */
+const verifiedHttpBundlePaths = new LRUCache({ maxEntries: 2000 });
 /**
  * SSR Module Loader with Redis Support.
  *
@@ -59,7 +85,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 +303,79 @@ 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+content)
+            const verifyKey = `${cachedEntry.tempPath}:${cachedEntry.contentHash}`;
+            if (!verifiedHttpBundlePaths.get(verifyKey)) {
+                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.set(verifyKey, true);
+                        }
+                    }
+                    else {
+                        verifiedHttpBundlePaths.set(verifyKey, true);
+                    }
+                }
+                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) {
+        if (isSSRDistributedCacheEnabled()) {
             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.set(`${tempPath}:${contentHash}`, true);
+                    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);
@@ -337,16 +448,33 @@ export class SSRModuleLoader {
                 // Rewrite local imports to use hashed temp paths
                 // This ensures that each content version uses its own cached module
                 transformed = this.rewriteLocalImports(transformed, localImportPaths, filePath);
+                // Ensure HTTP bundles exist for this transform (handles nested bundle deps)
+                const bundlePaths = extractHttpBundlePaths(transformed);
+                if (bundlePaths.length > 0) {
+                    const cacheDir = getHttpBundleCacheDir();
+                    const failed = await ensureHttpBundlesExist(bundlePaths, cacheDir);
+                    if (failed.length > 0) {
+                        logger.warn("[SSR-MODULE-LOADER] Some HTTP bundles could not be recovered", {
+                            file: filePath.slice(-40),
+                            failed,
+                        });
+                    }
+                }
                 // Hash the TRANSFORMED content (after import rewrites) for cache busting
                 // This ensures Deno's module cache is invalidated when dependencies change
                 const transformedHash = await this.hashContentAsync(transformed);
                 const tempPath = await this.getTempPath(filePath, transformedHash);
                 await this.fs.mkdir(tempPath.substring(0, tempPath.lastIndexOf("/")), { recursive: true });
                 await this.fs.writeTextFile(tempPath, transformed);
-                if (redisEnabled && redisClient) {
+                if (isSSRDistributedCacheEnabled()) {
                     setInRedis(contentCacheKey, transformed, {
                         isProduction: this.isProductionContentSource(),
-                    }).catch(() => { });
+                    }).catch((error) => {
+                        logger.debug("[SSR-MODULE-LOADER] Distributed cache set failed", {
+                            key: contentCacheKey,
+                            error,
+                        });
+                    });
                 }
                 // Use transformedHash for cache busting in dynamic imports
                 const entry = { tempPath, contentHash: transformedHash };