veryfront 0.0.72 → 0.0.74

package/dist/index.js

@@ -122,6 +122,47 @@ function resolveLogLevel(force = false) {
   }
   return cachedLogLevel;
 }
+function resolveLogFormat(force = false) {
+  if (force || cachedLogFormat === void 0) {
+    cachedLogFormat = getDefaultFormat();
+  }
+  return cachedLogFormat;
+}
+function getDefaultFormat() {
+  const envFormat = getEnvironmentVariable("LOG_FORMAT");
+  if (envFormat === "json" || envFormat === "text") {
+    return envFormat;
+  }
+  return isProductionEnvironment() ? "json" : "text";
+}
+function serializeError(err) {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+      stack: err.stack
+    };
+  }
+  if (err !== void 0 && err !== null) {
+    return {
+      name: "UnknownError",
+      message: String(err)
+    };
+  }
+  return void 0;
+}
+function extractContext(args) {
+  let context;
+  let error2;
+  for (const arg of args) {
+    if (arg instanceof Error) {
+      error2 = serializeError(arg);
+    } else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+      context = { ...context, ...arg };
+    }
+  }
+  return { context, error: error2 };
+}
 function parseLogLevel(levelString) {
   if (!levelString)
     return void 0;
@@ -146,8 +187,10 @@ function createLogger(prefix) {
 }
 function __loggerResetForTests(options = {}) {
   const updatedLevel = resolveLogLevel(true);
+  const updatedFormat = resolveLogFormat(true);
   for (const instance of trackedLoggers) {
     instance.setLevel(updatedLevel);
+    instance.setFormat(updatedFormat);
   }
   if (options.restoreConsole) {
     console.debug = originalConsole.debug;
@@ -156,7 +199,10 @@ function __loggerResetForTests(options = {}) {
     console.error = originalConsole.error;
   }
 }
-var LogLevel, originalConsole, cachedLogLevel, ConsoleLogger, getDefaultLevel, trackedLoggers, cliLogger, serverLogger, rendererLogger, bundlerLogger, agentLogger, logger;
+function createRequestLogger(baseLogger, requestContext) {
+  return baseLogger.child(requestContext);
+}
+var LogLevel, originalConsole, cachedLogLevel, cachedLogFormat, ConsoleLogger, getDefaultLevel, trackedLoggers, cliLogger, serverLogger, rendererLogger, bundlerLogger, agentLogger, proxyLogger, logger;
 var init_logger = __esm({
   "src/core/utils/logger/logger.ts"() {
     init_deno_env();
@@ -174,47 +220,104 @@ var init_logger = __esm({
       warn: console.warn,
       error: console.error
     };
-    ConsoleLogger = class {
-      constructor(prefix, level = resolveLogLevel()) {
+    ConsoleLogger = class _ConsoleLogger {
+      constructor(prefix, level = resolveLogLevel(), format = resolveLogFormat(), boundContext) {
         this.prefix = prefix;
         this.level = level;
+        this.format = format;
+        if (boundContext) {
+          this.boundContext = boundContext;
+        }
       }
+      boundContext = {};
       setLevel(level) {
         this.level = level;
       }
       getLevel() {
         return this.level;
       }
-      debug(message, ...args) {
-        if (this.level <= 0 /* DEBUG */) {
-          console.debug(`[${this.prefix}] DEBUG: ${message}`, ...args);
+      setFormat(format) {
+        this.format = format;
+      }
+      getFormat() {
+        return this.format;
+      }
+      /**
+       * Create a child logger with additional bound context.
+       */
+      child(context) {
+        return new _ConsoleLogger(this.prefix, this.level, this.format, {
+          ...this.boundContext,
+          ...context
+        });
+      }
+      formatJson(level, message, args) {
+        const { context, error: error2 } = extractContext(args);
+        const entry = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level,
+          service: this.prefix.toLowerCase(),
+          message
+        };
+        const mergedContext = { ...this.boundContext, ...context };
+        if (Object.keys(mergedContext).length > 0) {
+          if ("requestId" in mergedContext) {
+            entry.requestId = String(mergedContext.requestId);
+            delete mergedContext.requestId;
+          }
+          if ("traceId" in mergedContext) {
+            entry.traceId = String(mergedContext.traceId);
+            delete mergedContext.traceId;
+          }
+          if ("projectSlug" in mergedContext) {
+            entry.projectSlug = String(mergedContext.projectSlug);
+            delete mergedContext.projectSlug;
+          }
+          if ("durationMs" in mergedContext) {
+            entry.durationMs = Number(mergedContext.durationMs);
+            delete mergedContext.durationMs;
+          }
+          if (Object.keys(mergedContext).length > 0) {
+            entry.context = mergedContext;
+          }
         }
+        if (error2) {
+          entry.error = error2;
+        }
+        return JSON.stringify(entry);
       }
-      info(message, ...args) {
-        if (this.level <= 1 /* INFO */) {
-          console.log(`[${this.prefix}] ${message}`, ...args);
+      log(level, logLevel, consoleFn, message, args) {
+        if (this.level > logLevel)
+          return;
+        if (this.format === "json") {
+          consoleFn(this.formatJson(level, message, args));
+        } else {
+          const prefix = level === "info" ? "" : ` ${level.toUpperCase()}:`;
+          consoleFn(`[${this.prefix}]${prefix} ${message}`, ...args);
         }
       }
+      debug(message, ...args) {
+        this.log("debug", 0 /* DEBUG */, console.debug, message, args);
+      }
+      info(message, ...args) {
+        this.log("info", 1 /* INFO */, console.log, message, args);
+      }
       warn(message, ...args) {
-        if (this.level <= 2 /* WARN */) {
-          console.warn(`[${this.prefix}] WARN: ${message}`, ...args);
-        }
+        this.log("warn", 2 /* WARN */, console.warn, message, args);
       }
       error(message, ...args) {
-        if (this.level <= 3 /* ERROR */) {
-          console.error(`[${this.prefix}] ERROR: ${message}`, ...args);
-        }
+        this.log("error", 3 /* ERROR */, console.error, message, args);
       }
       async time(label, fn) {
         const start = performance.now();
         try {
           const result = await fn();
-          const end = performance.now();
-          this.debug(`${label} completed in ${(end - start).toFixed(2)}ms`);
+          const durationMs = performance.now() - start;
+          this.debug(`${label} completed`, { durationMs: Math.round(durationMs) });
           return result;
         } catch (error2) {
-          const end = performance.now();
-          this.error(`${label} failed after ${(end - start).toFixed(2)}ms`, error2);
+          const durationMs = performance.now() - start;
+          this.error(`${label} failed`, { durationMs: Math.round(durationMs) }, error2);
           throw error2;
         }
       }
@@ -235,6 +338,7 @@ var init_logger = __esm({
     rendererLogger = createLogger("RENDERER");
     bundlerLogger = createLogger("BUNDLER");
     agentLogger = createLogger("AGENT");
+    proxyLogger = createLogger("PROXY");
     logger = createLogger("VERYFRONT");
   }
 });
@@ -267,7 +371,6 @@ var init_build = __esm({
 var SECONDS_PER_MINUTE, MINUTES_PER_HOUR, HOURS_PER_DAY, MS_PER_SECOND, DEFAULT_LRU_MAX_ENTRIES, COMPONENT_LOADER_MAX_ENTRIES, COMPONENT_LOADER_TTL_MS, MDX_RENDERER_MAX_ENTRIES, MDX_RENDERER_TTL_MS, RENDERER_CORE_MAX_ENTRIES, RENDERER_CORE_TTL_MS, TSX_LAYOUT_MAX_ENTRIES, TSX_LAYOUT_TTL_MS, DATA_FETCHING_MAX_ENTRIES, DATA_FETCHING_TTL_MS, MDX_CACHE_TTL_PRODUCTION_MS, MDX_CACHE_TTL_DEVELOPMENT_MS, BUNDLE_CACHE_TTL_PRODUCTION_MS, BUNDLE_CACHE_TTL_DEVELOPMENT_MS, BUNDLE_MANIFEST_PROD_TTL_MS, BUNDLE_MANIFEST_DEV_TTL_MS, RSC_MANIFEST_CACHE_TTL_MS, SERVER_ACTION_DEFAULT_TTL_SEC, DENO_KV_SAFE_SIZE_LIMIT_BYTES, HTTP_CACHE_SHORT_MAX_AGE_SEC, HTTP_CACHE_MEDIUM_MAX_AGE_SEC, HTTP_CACHE_LONG_MAX_AGE_SEC, ONE_DAY_MS, CACHE_CLEANUP_INTERVAL_MS, LRU_DEFAULT_MAX_ENTRIES, LRU_DEFAULT_MAX_SIZE_BYTES, CLEANUP_INTERVAL_MULTIPLIER;
 var init_cache = __esm({
   "src/core/utils/constants/cache.ts"() {
-    "use strict";
     init_deno_env();
     SECONDS_PER_MINUTE = 60;
     MINUTES_PER_HOUR = 60;
@@ -310,7 +413,7 @@ var init_deno = __esm({
   "deno.json"() {
     deno_default = {
       name: "veryfront",
-      version: "0.0.71",
+      version: "0.0.74",
       nodeModulesDir: "auto",
       exclude: [
         "npm/",
@@ -395,12 +498,12 @@ var init_deno = __esm({
         csstype: "https://esm.sh/csstype@3.2.3",
         "@types/react": "https://esm.sh/@types/react@18.3.27?deps=csstype@3.2.3",
         "@types/react-dom": "https://esm.sh/@types/react-dom@18.3.7?deps=csstype@3.2.3",
-        react: "https://esm.sh/react@18.3.1",
-        "react-dom": "https://esm.sh/react-dom@18.3.1",
-        "react-dom/server": "https://esm.sh/react-dom@18.3.1/server",
-        "react-dom/client": "https://esm.sh/react-dom@18.3.1/client",
-        "react/jsx-runtime": "https://esm.sh/react@18.3.1/jsx-runtime",
-        "react/jsx-dev-runtime": "https://esm.sh/react@18.3.1/jsx-dev-runtime",
+        react: "npm:react@18.3.1",
+        "react-dom": "npm:react-dom@18.3.1",
+        "react-dom/server": "npm:react-dom@18.3.1/server.node",
+        "react-dom/client": "npm:react-dom@18.3.1/client",
+        "react/jsx-runtime": "npm:react@18.3.1/jsx-runtime",
+        "react/jsx-dev-runtime": "npm:react@18.3.1/jsx-dev-runtime",
         "@mdx-js/mdx": "npm:@mdx-js/mdx@3.0.0",
         "@mdx-js/react": "npm:@mdx-js/react@3.0.0",
         "unist-util-visit": "npm:unist-util-visit@5.0.0",
@@ -410,27 +513,36 @@ var init_deno = __esm({
         "remark-frontmatter": "npm:remark-frontmatter@5.0.0",
         "rehype-highlight": "npm:rehype-highlight@7.0.2",
         "rehype-slug": "npm:rehype-slug@6.0.0",
-        esbuild: "https://deno.land/x/esbuild@v0.20.1/wasm.js",
-        "esbuild/mod.js": "https://deno.land/x/esbuild@v0.20.1/mod.js",
+        esbuild: "npm:esbuild@0.20.2",
+        "esbuild/mod.js": "npm:esbuild@0.20.2",
         "es-module-lexer": "npm:es-module-lexer@1.5.0",
-        zod: "npm:zod@3.23.8",
+        zod: "npm:zod@3.25.76",
         "mime-types": "npm:mime-types@2.1.35",
         mdast: "npm:@types/mdast@4.0.3",
         hast: "npm:@types/hast@3.0.3",
         unist: "npm:@types/unist@3.0.2",
         unified: "npm:unified@11.0.5",
-        ai: "https://esm.sh/ai@5.0.76?deps=react@18.3.1,react-dom@18.3.1",
-        "ai/react": "https://esm.sh/@ai-sdk/react@2.0.1?deps=react@18.3.1,react-dom@18.3.1",
-        "@ai-sdk/react": "https://esm.sh/@ai-sdk/react@2.0.1?deps=react@18.3.1,react-dom@18.3.1",
+        ai: "npm:ai@5.0.76",
+        "ai/react": "npm:@ai-sdk/react@2.0.1",
+        "@ai-sdk/react": "npm:@ai-sdk/react@2.0.1",
         "@ai-sdk/openai": "https://esm.sh/@ai-sdk/openai@2.0.1",
         "@ai-sdk/anthropic": "https://esm.sh/@ai-sdk/anthropic@2.0.1",
         unocss: "https://esm.sh/unocss@0.59.0",
         "@unocss/core": "https://esm.sh/@unocss/core@0.59.0",
         "@unocss/preset-wind": "https://esm.sh/@unocss/preset-wind@0.59.0",
+        "next-themes": "npm:next-themes@0.3.0",
         redis: "npm:redis",
         pg: "npm:pg",
         "@opentelemetry/api": "npm:@opentelemetry/api@1",
-        "@opentelemetry/core": "npm:@opentelemetry/core@1"
+        "@opentelemetry/core": "npm:@opentelemetry/core@1",
+        "@opentelemetry/sdk-trace-base": "npm:@opentelemetry/sdk-trace-base@1",
+        "@opentelemetry/exporter-trace-otlp-http": "npm:@opentelemetry/exporter-trace-otlp-http@0.57",
+        "@opentelemetry/resources": "npm:@opentelemetry/resources@1",
+        "@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@1",
+        "@babel/parser": "npm:@babel/parser@7.26.3",
+        "@babel/traverse": "npm:@babel/traverse@7.26.3",
+        "@babel/generator": "npm:@babel/generator@7.26.3",
+        "@babel/types": "npm:@babel/types@7.26.3"
       },
       compilerOptions: {
         jsx: "react-jsx",
@@ -438,7 +550,7 @@ var init_deno = __esm({
         strict: true,
         noImplicitAny: true,
         noUncheckedIndexedAccess: true,
-        types: [],
+        types: ["npm:@types/react@18"],
         lib: [
           "deno.window",
           "dom",
@@ -453,9 +565,9 @@ var init_deno = __esm({
         build: "deno compile --allow-all --output ../../bin/veryfront src/cli/main.ts",
         "build:npm": "deno run -A scripts/build-npm.ts",
         release: "deno run -A scripts/release.ts",
-        test: "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --unstable-worker-options --unstable-net",
-        "test:unit": "DENO_JOBS=1 deno test --parallel --allow-all --v8-flags=--max-old-space-size=8192 --ignore=tests --unstable-worker-options --unstable-net",
-        "test:integration": "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all tests --unstable-worker-options --unstable-net",
+        test: "VF_DISABLE_LRU_INTERVAL=1 DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --unstable-worker-options --unstable-net",
+        "test:unit": "VF_DISABLE_LRU_INTERVAL=1 DENO_JOBS=1 deno test --parallel --allow-all --v8-flags=--max-old-space-size=8192 --ignore=tests,src/ai/workflow/__tests__ --unstable-worker-options --unstable-net",
+        "test:integration": "VF_DISABLE_LRU_INTERVAL=1 DENO_JOBS=1 deno test --parallel --fail-fast --allow-all tests --unstable-worker-options --unstable-net",
         "test:coverage": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage --unstable-worker-options --unstable-net || exit 1",
         "test:coverage:unit": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage --ignore=tests --unstable-worker-options --unstable-net || exit 1",
         "test:coverage:integration": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage tests --unstable-worker-options --unstable-net || exit 1",
@@ -518,12 +630,17 @@ var init_deno = __esm({
 });
 
 // src/platform/compat/runtime.ts
+function isNodeRuntime() {
+  const _global = globalThis;
+  const isRealDeno = typeof Deno !== "undefined" && typeof Deno.version === "object";
+  return !isRealDeno && typeof _global.process !== "undefined" && !!_global.process?.versions?.node;
+}
 var isDeno, isNode, isBun, isCloudflare;
 var init_runtime = __esm({
   "src/platform/compat/runtime.ts"() {
     "use strict";
     init_deno_env();
-    isDeno = typeof Deno !== "undefined";
+    isDeno = typeof Deno !== "undefined" && typeof Deno.version === "object";
     isNode = typeof globalThis.process !== "undefined" && globalThis.process?.versions?.node !== void 0;
     isBun = typeof globalThis.Bun !== "undefined";
     isCloudflare = typeof globalThis !== "undefined" && "caches" in globalThis && "WebSocketPair" in globalThis;
@@ -591,7 +708,7 @@ var init_process = __esm({
 });
 
 // src/core/utils/version.ts
-var VERSION;
+var VERSION, SERVER_START_TIME;
 var init_version = __esm({
   "src/core/utils/version.ts"() {
     "use strict";
@@ -599,6 +716,7 @@ var init_version = __esm({
     init_deno();
     init_process();
     VERSION = getEnv("VERYFRONT_VERSION") || (typeof deno_default.version === "string" ? deno_default.version : "0.0.0");
+    SERVER_START_TIME = Date.now();
   }
 });
 
@@ -637,10 +755,9 @@ function getDenoStdNodeBase() {
 function getUnoCSSTailwindResetUrl() {
   return `${ESM_CDN_BASE}/@unocss/reset@${UNOCSS_VERSION}/tailwind.css`;
 }
-var ESM_CDN_BASE, JSDELIVR_CDN_BASE, DENO_STD_BASE, REACT_VERSION_17, REACT_VERSION_18_2, REACT_VERSION_18_3, REACT_VERSION_19_RC, REACT_VERSION_19, REACT_DEFAULT_VERSION, DEFAULT_ALLOWED_CDN_HOSTS, DENO_STD_VERSION, UNOCSS_VERSION;
+var ESM_CDN_BASE, JSDELIVR_CDN_BASE, DENO_STD_BASE, REACT_VERSION_17, REACT_VERSION_18_2, REACT_VERSION_18_3, REACT_VERSION_19_RC, REACT_VERSION_19, REACT_DEFAULT_VERSION, DEFAULT_ALLOWED_CDN_HOSTS, DENO_STD_VERSION, TAILWIND_VERSION, UNOCSS_VERSION;
 var init_cdn = __esm({
   "src/core/utils/constants/cdn.ts"() {
-    "use strict";
     init_deno_env();
     init_version();
     ESM_CDN_BASE = "https://esm.sh";
@@ -654,6 +771,7 @@ var init_cdn = __esm({
     REACT_DEFAULT_VERSION = REACT_VERSION_18_3;
     DEFAULT_ALLOWED_CDN_HOSTS = [ESM_CDN_BASE, DENO_STD_BASE];
     DENO_STD_VERSION = "0.220.0";
+    TAILWIND_VERSION = "4.1.8";
     UNOCSS_VERSION = "0.59.0";
   }
 });
@@ -912,7 +1030,6 @@ function normalizeChunkPath(filename, basePath = INTERNAL_PATH_PREFIXES.CHUNKS)
 var DEFAULT_DASHBOARD_PORT, INTERNAL_PREFIX, INTERNAL_PATH_PREFIXES, INTERNAL_ENDPOINTS, BUILD_DIRS, PROJECT_DIRS, DEFAULT_CACHE_DIR, DEV_SERVER_ENDPOINTS;
 var init_server = __esm({
   "src/core/utils/constants/server.ts"() {
-    "use strict";
     init_deno_env();
     init_defaults();
     DEFAULT_DASHBOARD_PORT = 3002;
@@ -1421,8 +1538,8 @@ var init_bundle_manifest = __esm({
 // src/core/utils/bundle-manifest-init.ts
 async function initializeBundleManifest(config, mode, adapter) {
   const manifestConfig = config.cache?.bundleManifest;
-  const enabled = manifestConfig?.enabled ?? mode === "production";
-  if (!enabled) {
+  const enabled2 = manifestConfig?.enabled ?? mode === "production";
+  if (!enabled2) {
     serverLogger.info("[bundle-manifest] Bundle manifest disabled");
     setBundleManifestStore(new InMemoryBundleManifestStore());
     return;
@@ -1564,6 +1681,379 @@ var init_platform = __esm({
   }
 });
 
+// src/core/utils/import-lockfile.ts
+function createEmptyLockfile() {
+  return {
+    version: LOCKFILE_VERSION,
+    imports: {}
+  };
+}
+async function computeIntegrity(content) {
+  const hash = await computeHash(content);
+  return `sha256-${hash}`;
+}
+function verifyIntegrity(content, integrity) {
+  return computeIntegrity(content).then((computed) => computed === integrity);
+}
+function createNodeFSAdapter() {
+  const fs = globalThis.Deno ? null : __require2("fs/promises");
+  return {
+    readFile(path) {
+      if (globalThis.Deno) {
+        return Deno.readTextFile(path);
+      }
+      return fs.readFile(path, "utf-8");
+    },
+    async writeFile(path, content) {
+      if (globalThis.Deno) {
+        await Deno.writeTextFile(path, content);
+        return;
+      }
+      await fs.writeFile(path, content, "utf-8");
+    },
+    async exists(path) {
+      try {
+        if (globalThis.Deno) {
+          await Deno.stat(path);
+          return true;
+        }
+        await fs.access(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async remove(path) {
+      if (globalThis.Deno) {
+        await Deno.remove(path);
+        return;
+      }
+      await fs.unlink(path);
+    }
+  };
+}
+function createLockfileManager(projectDir, fsAdapter) {
+  const fs = fsAdapter || createNodeFSAdapter();
+  const lockfilePath = `${projectDir}/${LOCKFILE_NAME}`;
+  let cache = null;
+  let dirty = false;
+  const read = async () => {
+    if (cache)
+      return cache;
+    try {
+      if (await fs.exists(lockfilePath)) {
+        const content = await fs.readFile(lockfilePath);
+        cache = JSON.parse(content);
+        if (cache.version !== LOCKFILE_VERSION) {
+          serverLogger.warn(
+            `[lockfile] Version mismatch, expected ${LOCKFILE_VERSION}, got ${cache.version}`
+          );
+          cache = createEmptyLockfile();
+        }
+        return cache;
+      }
+    } catch (e) {
+      serverLogger.debug(`[lockfile] Could not read lockfile: ${e}`);
+    }
+    return null;
+  };
+  const write = async (data) => {
+    cache = data;
+    const sorted = {
+      version: data.version,
+      imports: Object.fromEntries(
+        Object.entries(data.imports).sort(([a], [b]) => a.localeCompare(b))
+      )
+    };
+    await fs.writeFile(lockfilePath, JSON.stringify(sorted, null, 2) + "\n");
+    dirty = false;
+    serverLogger.debug(`[lockfile] Written ${Object.keys(data.imports).length} entries`);
+  };
+  const get = async (url) => {
+    const data = await read();
+    return data?.imports[url] ?? null;
+  };
+  const set = async (url, entry) => {
+    let data = await read();
+    if (!data) {
+      data = createEmptyLockfile();
+    }
+    data.imports[url] = entry;
+    cache = data;
+    dirty = true;
+  };
+  const has = async (url) => {
+    const data = await read();
+    return url in (data?.imports ?? {});
+  };
+  const clear = async () => {
+    cache = createEmptyLockfile();
+    if (fs.remove && await fs.exists(lockfilePath)) {
+      await fs.remove(lockfilePath);
+    }
+  };
+  const flush = async () => {
+    if (dirty && cache) {
+      await write(cache);
+    }
+  };
+  return {
+    read,
+    write,
+    get,
+    set,
+    has,
+    clear,
+    flush
+  };
+}
+async function fetchWithLock(options) {
+  const { lockfile, url, fetchFn = fetch, strict = false } = options;
+  const entry = await lockfile.get(url);
+  if (entry) {
+    serverLogger.debug(`[lockfile] Cache hit for ${url}`);
+    const res2 = await fetchFn(entry.resolved, {
+      headers: { "user-agent": "Mozilla/5.0 Veryfront/1.0" }
+    });
+    if (!res2.ok) {
+      if (strict) {
+        throw new Error(
+          `Lockfile entry stale: ${url} resolved to ${entry.resolved} returned ${res2.status}`
+        );
+      }
+      serverLogger.warn(`[lockfile] Cached URL ${entry.resolved} returned ${res2.status}, refetching`);
+    } else {
+      const content2 = await res2.text();
+      const currentIntegrity = await computeIntegrity(content2);
+      if (currentIntegrity !== entry.integrity) {
+        if (strict) {
+          throw new Error(
+            `Integrity mismatch for ${url}: expected ${entry.integrity}, got ${currentIntegrity}`
+          );
+        }
+        serverLogger.warn(`[lockfile] Integrity mismatch for ${url}, updating lockfile`);
+      } else {
+        return {
+          content: content2,
+          resolvedUrl: entry.resolved,
+          fromCache: true,
+          integrity: entry.integrity
+        };
+      }
+    }
+  }
+  serverLogger.debug(`[lockfile] Fetching fresh: ${url}`);
+  const res = await fetchFn(url, {
+    headers: { "user-agent": "Mozilla/5.0 Veryfront/1.0" },
+    redirect: "follow"
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to fetch ${url}: ${res.status}`);
+  }
+  const content = await res.text();
+  const resolvedUrl = res.url || url;
+  const integrity = await computeIntegrity(content);
+  await lockfile.set(url, {
+    resolved: resolvedUrl,
+    integrity,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await lockfile.flush();
+  return {
+    content,
+    resolvedUrl,
+    fromCache: false,
+    integrity
+  };
+}
+function extractImports(content) {
+  const imports = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of content.matchAll(IMPORT_REGEX)) {
+    const specifier = match[1];
+    if (specifier && !seen.has(specifier)) {
+      seen.add(specifier);
+      imports.push({ specifier, type: "static" });
+    }
+  }
+  for (const match of content.matchAll(EXPORT_FROM_REGEX)) {
+    const specifier = match[1];
+    if (specifier && !seen.has(specifier)) {
+      seen.add(specifier);
+      imports.push({ specifier, type: "static" });
+    }
+  }
+  for (const match of content.matchAll(DYNAMIC_IMPORT_REGEX)) {
+    const specifier = match[1];
+    if (specifier && !seen.has(specifier)) {
+      seen.add(specifier);
+      imports.push({ specifier, type: "dynamic" });
+    }
+  }
+  return imports;
+}
+function resolveImportUrl(specifier, baseUrl) {
+  if (specifier.startsWith("http://") || specifier.startsWith("https://")) {
+    return specifier;
+  }
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    try {
+      return new URL(specifier, baseUrl).toString();
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+var LOCKFILE_NAME, LOCKFILE_VERSION, IMPORT_REGEX, DYNAMIC_IMPORT_REGEX, EXPORT_FROM_REGEX;
+var init_import_lockfile = __esm({
+  "src/core/utils/import-lockfile.ts"() {
+    "use strict";
+    init_deno_env();
+    init_hash_utils();
+    init_logger2();
+    LOCKFILE_NAME = "veryfront.lock";
+    LOCKFILE_VERSION = 1;
+    IMPORT_REGEX = /import\s+(?:(?:[\w*\s{},]*)\s+from\s+)?['"]([^'"]+)['"]/g;
+    DYNAMIC_IMPORT_REGEX = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    EXPORT_FROM_REGEX = /export\s+(?:[\w*\s{},]*)\s+from\s+['"]([^'"]+)['"]/g;
+  }
+});
+
+// src/core/utils/perf-timer.ts
+function startRequest(requestId) {
+  if (!enabled)
+    return;
+  currentRequestId = requestId;
+  timings.set(requestId, []);
+}
+function startTimer(label, parent) {
+  if (!enabled || !currentRequestId)
+    return () => {
+    };
+  const entry = {
+    label,
+    startMs: performance.now(),
+    parent
+  };
+  const entries = timings.get(currentRequestId);
+  if (entries) {
+    entries.push(entry);
+  }
+  return () => {
+    entry.endMs = performance.now();
+    entry.durationMs = entry.endMs - entry.startMs;
+  };
+}
+async function timeAsync(label, fn, parent) {
+  if (!enabled)
+    return fn();
+  const stop = startTimer(label, parent);
+  try {
+    return await fn();
+  } finally {
+    stop();
+  }
+}
+function endRequest(requestId) {
+  if (!enabled)
+    return;
+  const entries = timings.get(requestId);
+  if (!entries || entries.length === 0) {
+    currentRequestId = null;
+    return;
+  }
+  const sorted = entries.filter((e) => e.durationMs !== void 0).sort((a, b) => (b.durationMs || 0) - (a.durationMs || 0));
+  const total = entries.find((e) => e.label === "total")?.durationMs || sorted.reduce((sum, e) => sum + (e.durationMs || 0), 0);
+  console.log(`
+[PERF] Request ${requestId} - Total: ${total.toFixed(1)}ms`);
+  console.log("\u2500".repeat(60));
+  const roots = sorted.filter((e) => !e.parent);
+  const children = /* @__PURE__ */ new Map();
+  for (const entry of sorted) {
+    if (entry.parent) {
+      const list = children.get(entry.parent) || [];
+      list.push(entry);
+      children.set(entry.parent, list);
+    }
+  }
+  for (const entry of roots) {
+    const pct = ((entry.durationMs || 0) / total * 100).toFixed(1);
+    console.log(`  ${entry.label}: ${entry.durationMs?.toFixed(1)}ms (${pct}%)`);
+    const childList = children.get(entry.label);
+    if (childList) {
+      for (const child of childList.slice(0, 5)) {
+        const childPct = ((child.durationMs || 0) / total * 100).toFixed(1);
+        console.log(`    \u2514\u2500 ${child.label}: ${child.durationMs?.toFixed(1)}ms (${childPct}%)`);
+      }
+      if (childList.length > 5) {
+        console.log(`    \u2514\u2500 ... and ${childList.length - 5} more`);
+      }
+    }
+  }
+  console.log("\u2500".repeat(60));
+  timings.delete(requestId);
+  currentRequestId = null;
+}
+function isEnabled() {
+  return enabled;
+}
+var enabled, timings, currentRequestId;
+var init_perf_timer = __esm({
+  "src/core/utils/perf-timer.ts"() {
+    "use strict";
+    init_deno_env();
+    enabled = typeof process !== "undefined" ? process.env?.VERYFRONT_PERF === "1" : typeof Deno !== "undefined" ? Deno.env.get("VERYFRONT_PERF") === "1" : false;
+    timings = /* @__PURE__ */ new Map();
+    currentRequestId = null;
+  }
+});
+
+// src/core/utils/cookie-utils.ts
+function parseCookies(cookieHeader) {
+  const cookies = {};
+  if (!cookieHeader)
+    return cookies;
+  cookieHeader.split(";").forEach((cookie) => {
+    const trimmed = cookie.trim();
+    if (!trimmed)
+      return;
+    const separatorIndex = trimmed.indexOf("=");
+    if (separatorIndex <= 0)
+      return;
+    const name = trimmed.slice(0, separatorIndex).trim();
+    const value = trimmed.slice(separatorIndex + 1);
+    if (!name)
+      return;
+    cookies[name] = decodeURIComponent(value);
+  });
+  return cookies;
+}
+function parseCookiesFromHeaders(headers) {
+  return parseCookies(headers.get("cookie") || "");
+}
+var init_cookie_utils = __esm({
+  "src/core/utils/cookie-utils.ts"() {
+    init_deno_env();
+  }
+});
+
+// src/core/utils/base64url.ts
+function base64urlEncode(input) {
+  const b64 = btoa(input);
+  return b64.replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function base64urlEncodeBytes(bytes) {
+  const b64 = btoa(String.fromCharCode(...bytes));
+  return b64.replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+var init_base64url = __esm({
+  "src/core/utils/base64url.ts"() {
+    "use strict";
+    init_deno_env();
+  }
+});
+
 // src/core/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -1711,6 +2201,7 @@ __export(utils_exports, {
   SECONDS_PER_MINUTE: () => SECONDS_PER_MINUTE,
   SERVER_ACTION_DEFAULT_TTL_SEC: () => SERVER_ACTION_DEFAULT_TTL_SEC,
   SERVER_FUNCTION_DEFAULT_TIMEOUT_MS: () => SERVER_FUNCTION_DEFAULT_TIMEOUT_MS,
+  TAILWIND_VERSION: () => TAILWIND_VERSION,
   TSX_LAYOUT_MAX_ENTRIES: () => TSX_LAYOUT_MAX_ENTRIES,
   TSX_LAYOUT_TTL_MS: () => TSX_LAYOUT_TTL_MS,
   UNOCSS_VERSION: () => UNOCSS_VERSION,
@@ -1721,13 +2212,22 @@ __export(utils_exports, {
   Z_INDEX_ERROR_OVERLAY: () => Z_INDEX_ERROR_OVERLAY,
   __loggerResetForTests: () => __loggerResetForTests,
   agentLogger: () => agentLogger,
+  base64urlEncode: () => base64urlEncode,
+  base64urlEncodeBytes: () => base64urlEncodeBytes,
   bundlerLogger: () => bundlerLogger,
   cliLogger: () => cliLogger,
   computeCodeHash: () => computeCodeHash,
   computeContentHash: () => computeContentHash,
   computeHash: () => computeHash,
+  computeIntegrity: () => computeIntegrity,
+  createEmptyLockfile: () => createEmptyLockfile,
+  createLockfileManager: () => createLockfileManager,
+  createRequestLogger: () => createRequestLogger,
+  endRequest: () => endRequest,
   estimateSize: () => estimateSize,
   estimateSizeWithCircularHandling: () => estimateSizeWithCircularHandling,
+  extractImports: () => extractImports,
+  fetchWithLock: () => fetchWithLock,
   formatBytes: () => formatBytes,
   formatDuration: () => formatDuration,
   formatNumber: () => formatNumber,
@@ -1758,6 +2258,7 @@ __export(utils_exports, {
   isDebugEnabled: () => isDebugEnabled,
   isDeepInspectEnabled: () => isDeepInspectEnabled,
   isDevelopmentEnvironment: () => isDevelopmentEnvironment,
+  isEnabled: () => isEnabled,
   isInternalEndpoint: () => isInternalEndpoint,
   isProductionEnvironment: () => isProductionEnvironment,
   isRSCEnabled: () => isRSCEnabled,
@@ -1774,13 +2275,21 @@ __export(utils_exports, {
   normalizeChunkPath: () => normalizeChunkPath,
   normalizePath: () => normalizePath,
   numericHash: () => simpleHash,
+  parseCookies: () => parseCookies,
+  parseCookiesFromHeaders: () => parseCookiesFromHeaders,
+  proxyLogger: () => proxyLogger,
   rendererLogger: () => rendererLogger,
+  resolveImportUrl: () => resolveImportUrl,
   serverLogger: () => serverLogger,
   setBundleManifestStore: () => setBundleManifestStore,
   shortHash: () => shortHash,
   simpleHash: () => simpleHash,
+  startRequest: () => startRequest,
+  startTimer: () => startTimer,
+  timeAsync: () => timeAsync,
   toBase64Url: () => toBase64Url,
   truncateString: () => truncateString,
+  verifyIntegrity: () => verifyIntegrity,
   warmupBundleManifest: () => warmupBundleManifest
 });
 var init_utils = __esm({
@@ -1799,6 +2308,10 @@ var init_utils = __esm({
     init_bundle_manifest_init();
     init_feature_flags();
     init_platform();
+    init_import_lockfile();
+    init_perf_timer();
+    init_cookie_utils();
+    init_base64url();
   }
 });
 
@@ -1825,6 +2338,56 @@ var init_veryfront_error = __esm({
 
 // src/core/config/schema.ts
 import { z } from "zod";
+function validateVeryfrontConfig(input) {
+  const parsed = veryfrontConfigSchema.safeParse(input);
+  if (!parsed.success) {
+    const first = parsed.error.issues[0];
+    const path = first?.path?.length ? first.path.join(".") : "<root>";
+    const expected = first?.message || String(first);
+    let hint = "";
+    if (String(path).includes("security.cors")) {
+      hint = " Expected boolean or { origin?: string }.";
+    }
+    const context = {
+      field: path,
+      expected: expected + hint,
+      value: input
+    };
+    throw toError(
+      createError({
+        type: "config",
+        message: `Invalid veryfront.config at ${path}: ${expected}.${hint}`,
+        context
+      })
+    );
+  }
+  return parsed.data;
+}
+function findUnknownTopLevelKeys(input) {
+  const known = /* @__PURE__ */ new Set([
+    "title",
+    "description",
+    "experimental",
+    "router",
+    "defaultLayout",
+    "layout",
+    "provider",
+    "app",
+    "theme",
+    "build",
+    "cache",
+    "dev",
+    "resolve",
+    "security",
+    "middleware",
+    "theming",
+    "assetPipeline",
+    "observability",
+    "fs",
+    "client"
+  ]);
+  return Object.keys(input).filter((k) => !known.has(k));
+}
 var corsSchema, veryfrontConfigSchema;
 var init_schema = __esm({
   "src/core/config/schema.ts"() {
@@ -1841,6 +2404,9 @@ var init_schema = __esm({
       }).partial().optional(),
       router: z.enum(["app", "pages"]).optional(),
       defaultLayout: z.string().optional(),
+      layout: z.string().optional(),
+      provider: z.string().optional(),
+      app: z.string().optional(),
       theme: z.object({ colors: z.record(z.string()).optional() }).partial().optional(),
       build: z.object({
         outDir: z.string().optional(),
@@ -1936,6 +2502,8 @@ var init_schema = __esm({
           apiBaseUrl: z.string().url(),
           apiToken: z.string(),
           projectSlug: z.string(),
+          proxyMode: z.boolean().optional(),
+          productionMode: z.boolean().optional(),
           cache: z.object({
             enabled: z.boolean().optional(),
             ttl: z.number().int().positive().optional(),
@@ -1968,83 +2536,449 @@ var init_schema = __esm({
   }
 });
 
-// src/core/config/loader.ts
-import { join } from "node:path";
-function getDefaultImportMapForConfig() {
-  return { imports: getReactImportMap(REACT_DEFAULT_VERSION) };
-}
-var DEFAULT_CONFIG;
-var init_loader = __esm({
-  "src/core/config/loader.ts"() {
-    "use strict";
-    init_deno_env();
-    init_schema();
-    init_logger();
-    init_cdn();
-    init_server();
-    init_defaults();
-    DEFAULT_CONFIG = {
-      title: "Veryfront App",
-      description: "Built with Veryfront",
-      experimental: {
-        esmLayouts: true
-      },
-      router: void 0,
-      defaultLayout: void 0,
-      theme: {
-        colors: {
-          primary: "#3B82F6"
-        }
-      },
-      build: {
-        outDir: "dist",
-        trailingSlash: false,
-        esbuild: {
-          wasmURL: "https://deno.land/x/esbuild@v0.20.1/esbuild.wasm",
-          worker: false
-        }
-      },
-      cache: {
-        dir: DEFAULT_CACHE_DIR,
-        render: {
-          type: "memory",
-          ttl: void 0,
-          maxEntries: 500,
-          kvPath: void 0,
-          redisUrl: void 0,
-          redisKeyPrefix: void 0
-        }
-      },
-      dev: {
-        port: DEFAULT_PORT,
-        host: "localhost",
-        open: false
-      },
-      resolve: {
-        importMap: getDefaultImportMapForConfig()
-      },
-      client: {
-        moduleResolution: "cdn",
-        cdn: {
-          provider: "esm.sh",
-          versions: "auto"
-        }
-      }
-    };
+// src/platform/compat/fs.ts
+function createFileSystem() {
+  if (isDeno) {
+    return new DenoFileSystem();
+  } else {
+    return new NodeFileSystem();
   }
-});
-
-// src/core/config/define-config.ts
-function defineConfig(config) {
-  return config;
 }
-var init_define_config = __esm({
-  "src/core/config/define-config.ts"() {
+var NodeFileSystem, DenoFileSystem;
+var init_fs = __esm({
+  "src/platform/compat/fs.ts"() {
     "use strict";
     init_deno_env();
     init_veryfront_error();
-    init_process();
-  }
+    init_runtime();
+    NodeFileSystem = class {
+      constructor() {
+        this.fs = null;
+        this.os = null;
+        this.path = null;
+        this.initialized = false;
+      }
+      async ensureInitialized() {
+        if (this.initialized)
+          return;
+        if (!isNode) {
+          throw toError(createError({
+            type: "not_supported",
+            message: "Node.js fs modules not available",
+            feature: "Node.js"
+          }));
+        }
+        const [fsModule, osModule, pathModule] = await Promise.all([
+          import("node:fs/promises"),
+          import("node:os"),
+          import("node:path")
+        ]);
+        this.fs = fsModule;
+        this.os = osModule;
+        this.path = pathModule;
+        this.initialized = true;
+      }
+      async readTextFile(path) {
+        await this.ensureInitialized();
+        return await this.fs.readFile(path, { encoding: "utf8" });
+      }
+      async readFile(path) {
+        await this.ensureInitialized();
+        return await this.fs.readFile(path);
+      }
+      async writeTextFile(path, data) {
+        await this.ensureInitialized();
+        await this.fs.writeFile(path, data, { encoding: "utf8" });
+      }
+      async writeFile(path, data) {
+        await this.ensureInitialized();
+        await this.fs.writeFile(path, data);
+      }
+      async exists(path) {
+        await this.ensureInitialized();
+        try {
+          await this.fs.access(path);
+          return true;
+        } catch (error2) {
+          if (error2.code === "ENOENT") {
+            return false;
+          }
+          throw error2;
+        }
+      }
+      async stat(path) {
+        await this.ensureInitialized();
+        const stat = await this.fs.stat(path);
+        return {
+          isFile: stat.isFile(),
+          isDirectory: stat.isDirectory(),
+          isSymlink: stat.isSymbolicLink(),
+          size: stat.size,
+          mtime: stat.mtime
+        };
+      }
+      async mkdir(path, options) {
+        await this.ensureInitialized();
+        await this.fs.mkdir(path, { recursive: options?.recursive ?? false });
+      }
+      async *readDir(path) {
+        await this.ensureInitialized();
+        const entries = await this.fs.readdir(path, { withFileTypes: true });
+        for (const entry of entries) {
+          yield {
+            name: entry.name,
+            isFile: entry.isFile(),
+            isDirectory: entry.isDirectory()
+          };
+        }
+      }
+      async remove(path, options) {
+        await this.ensureInitialized();
+        await this.fs.rm(path, {
+          recursive: options?.recursive ?? false,
+          force: options?.recursive ?? false
+        });
+      }
+      async makeTempDir(options) {
+        await this.ensureInitialized();
+        const tempDir = this.path.join(
+          this.os.tmpdir(),
+          `${options?.prefix ?? "tmp-"}${Math.random().toString(36).substring(2, 8)}`
+        );
+        await this.fs.mkdir(tempDir, { recursive: true });
+        return tempDir;
+      }
+    };
+    DenoFileSystem = class {
+      async readTextFile(path) {
+        return await Deno.readTextFile(path);
+      }
+      async readFile(path) {
+        return await Deno.readFile(path);
+      }
+      async writeTextFile(path, data) {
+        await Deno.writeTextFile(path, data);
+      }
+      async writeFile(path, data) {
+        await Deno.writeFile(path, data);
+      }
+      async exists(path) {
+        try {
+          await Deno.stat(path);
+          return true;
+        } catch (error2) {
+          if (error2 instanceof Deno.errors.NotFound) {
+            return false;
+          }
+          throw error2;
+        }
+      }
+      async stat(path) {
+        const stat = await Deno.stat(path);
+        return {
+          isFile: stat.isFile,
+          isDirectory: stat.isDirectory,
+          isSymlink: stat.isSymlink,
+          size: stat.size,
+          mtime: stat.mtime
+        };
+      }
+      async mkdir(path, options) {
+        await Deno.mkdir(path, { recursive: options?.recursive ?? false });
+      }
+      async *readDir(path) {
+        for await (const entry of Deno.readDir(path)) {
+          yield {
+            name: entry.name,
+            isFile: entry.isFile,
+            isDirectory: entry.isDirectory
+          };
+        }
+      }
+      async remove(path, options) {
+        await Deno.remove(path, { recursive: options?.recursive ?? false });
+      }
+      async makeTempDir(options) {
+        return await Deno.makeTempDir({ prefix: options?.prefix });
+      }
+    };
+  }
+});
+
+// src/core/config/loader.ts
+import { dirname, join } from "node:path";
+function getDefaultImportMapForConfig() {
+  return { imports: getReactImportMap(REACT_DEFAULT_VERSION) };
+}
+function validateCorsConfig(userConfig) {
+  if (!userConfig || typeof userConfig !== "object") {
+    return;
+  }
+  const config = userConfig;
+  const security = config.security;
+  const cors2 = security?.cors;
+  if (!cors2 || typeof cors2 !== "object" || Array.isArray(cors2)) {
+    return;
+  }
+  const corsObj = cors2;
+  const origin = corsObj.origin;
+  if (origin !== void 0 && typeof origin !== "string") {
+    throw new ConfigValidationError(
+      "security.cors.origin must be a string. Expected boolean or { origin?: string }"
+    );
+  }
+}
+function validateConfigShape(userConfig) {
+  validateVeryfrontConfig(userConfig);
+  const unknown = typeof userConfig === "object" && userConfig ? findUnknownTopLevelKeys(userConfig) : [];
+  if (unknown.length > 0) {
+    serverLogger.warn(`Unknown config keys: ${unknown.join(", ")}. These will be ignored.`);
+  }
+}
+function mergeConfigs(userConfig) {
+  const merged = {
+    ...DEFAULT_CONFIG,
+    ...userConfig,
+    dev: {
+      ...DEFAULT_CONFIG.dev,
+      ...userConfig.dev
+    },
+    theme: {
+      ...DEFAULT_CONFIG.theme,
+      ...userConfig.theme
+    },
+    build: {
+      ...DEFAULT_CONFIG.build,
+      ...userConfig.build
+    },
+    cache: {
+      ...DEFAULT_CONFIG.cache,
+      ...userConfig.cache
+    },
+    resolve: {
+      ...DEFAULT_CONFIG.resolve,
+      ...userConfig.resolve
+    },
+    client: {
+      ...DEFAULT_CONFIG.client,
+      ...userConfig.client,
+      cdn: {
+        ...DEFAULT_CONFIG.client?.cdn,
+        ...userConfig.client?.cdn
+      }
+    }
+  };
+  if (merged.resolve) {
+    const defaultMap = DEFAULT_CONFIG.resolve?.importMap;
+    const userMap = userConfig.resolve?.importMap;
+    if (defaultMap || userMap) {
+      merged.resolve.importMap = {
+        imports: {
+          ...defaultMap?.imports ?? {},
+          ...userMap?.imports ?? {}
+        },
+        scopes: {
+          ...defaultMap?.scopes ?? {},
+          ...userMap?.scopes ?? {}
+        }
+      };
+    }
+  }
+  return merged;
+}
+function isVirtualFilesystem(adapter) {
+  const wrappedAdapter = adapter?.fs?.fsAdapter;
+  const adapterName = wrappedAdapter?.constructor?.name;
+  return adapterName === "VeryfrontFSAdapter";
+}
+async function loadConfigFromVirtualFS(configPath, projectDir, adapter) {
+  const fs = createFileSystem();
+  const content = await adapter.fs.readFile(configPath);
+  const source = typeof content === "string" ? content : new TextDecoder().decode(content);
+  serverLogger.debug(`[CONFIG] Loading config from virtual FS: ${configPath}`);
+  const isTsx = configPath.endsWith(".tsx");
+  const loader = isTsx ? "tsx" : configPath.endsWith(".ts") ? "ts" : "js";
+  const { build: build2 } = await import("esbuild");
+  const result = await build2({
+    bundle: false,
+    // Config files shouldn't need bundling
+    write: false,
+    format: "esm",
+    platform: "neutral",
+    target: "es2022",
+    stdin: {
+      contents: source,
+      loader,
+      resolveDir: dirname(configPath),
+      sourcefile: configPath
+    }
+  });
+  if (result.errors && result.errors.length > 0) {
+    const first = result.errors[0]?.text || "unknown error";
+    throw new ConfigValidationError(`Failed to transpile config: ${first}`);
+  }
+  const js = result.outputFiles?.[0]?.text ?? "export default {}";
+  const tempDir = await fs.makeTempDir({ prefix: "vf-config-" });
+  const tempFile = join(tempDir, "config.mjs");
+  try {
+    await fs.writeTextFile(tempFile, js);
+    const configModule = await import(`file://${tempFile}?v=${Date.now()}`);
+    const userConfig = configModule.default || configModule;
+    if (userConfig === null || typeof userConfig !== "object" || Array.isArray(userConfig)) {
+      throw new ConfigValidationError(
+        `Expected object, received ${userConfig === null ? "null" : typeof userConfig}`
+      );
+    }
+    validateCorsConfig(userConfig);
+    validateConfigShape(userConfig);
+    const merged = mergeConfigs(userConfig);
+    configCacheByProject.set(projectDir, { revision: cacheRevision, config: merged });
+    return merged;
+  } finally {
+    await fs.remove(tempDir, { recursive: true });
+  }
+}
+async function loadAndMergeConfig(configPath, projectDir, adapter) {
+  if (isVirtualFilesystem(adapter)) {
+    return loadConfigFromVirtualFS(configPath, projectDir, adapter);
+  }
+  try {
+    const configUrl = `file://${configPath}?t=${Date.now()}-${crypto.randomUUID()}`;
+    const configModule = await import(configUrl);
+    const userConfig = configModule.default || configModule;
+    if (userConfig === null || typeof userConfig !== "object" || Array.isArray(userConfig)) {
+      throw new ConfigValidationError(
+        `Expected object, received ${userConfig === null ? "null" : typeof userConfig}`
+      );
+    }
+    validateCorsConfig(userConfig);
+    validateConfigShape(userConfig);
+    const merged = mergeConfigs(userConfig);
+    configCacheByProject.set(projectDir, { revision: cacheRevision, config: merged });
+    return merged;
+  } catch (error2) {
+    if (error2 instanceof ConfigValidationError) {
+      throw error2;
+    }
+    if (error2 instanceof Error && error2.message.startsWith("Invalid veryfront.config")) {
+      throw error2;
+    }
+    throw error2;
+  }
+}
+async function getConfig(projectDir, adapter) {
+  const cached = configCacheByProject.get(projectDir);
+  if (cached && cached.revision === cacheRevision)
+    return cached.config;
+  const configFiles = ["veryfront.config.js", "veryfront.config.ts", "veryfront.config.mjs"];
+  for (const configFile of configFiles) {
+    const configPath = join(projectDir, configFile);
+    const exists = await adapter.fs.exists(configPath);
+    if (!exists)
+      continue;
+    try {
+      const merged = await loadAndMergeConfig(configPath, projectDir, adapter);
+      if (merged)
+        return merged;
+    } catch (error2) {
+      if (error2 instanceof ConfigValidationError) {
+        throw error2;
+      }
+      if (error2 instanceof Error && error2.message.startsWith("Invalid veryfront.config")) {
+        throw error2;
+      }
+      const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+      serverLogger.debug(`[CONFIG] Failed to load ${configFile}, trying next config file:`, {
+        error: errorMessage
+      });
+      continue;
+    }
+  }
+  const defaultConfig2 = DEFAULT_CONFIG;
+  configCacheByProject.set(projectDir, { revision: cacheRevision, config: defaultConfig2 });
+  return defaultConfig2;
+}
+var DEFAULT_CONFIG, configCacheByProject, cacheRevision, ConfigValidationError;
+var init_loader = __esm({
+  "src/core/config/loader.ts"() {
+    "use strict";
+    init_deno_env();
+    init_schema();
+    init_logger();
+    init_cdn();
+    init_server();
+    init_defaults();
+    init_fs();
+    DEFAULT_CONFIG = {
+      title: "Veryfront App",
+      description: "Built with Veryfront",
+      experimental: {
+        esmLayouts: true
+      },
+      router: void 0,
+      defaultLayout: void 0,
+      theme: {
+        colors: {
+          primary: "#3B82F6"
+        }
+      },
+      build: {
+        outDir: "dist",
+        trailingSlash: false,
+        esbuild: {
+          wasmURL: "https://deno.land/x/esbuild@v0.20.1/esbuild.wasm",
+          worker: false
+        }
+      },
+      cache: {
+        dir: DEFAULT_CACHE_DIR,
+        render: {
+          type: "memory",
+          ttl: void 0,
+          maxEntries: 500,
+          kvPath: void 0,
+          redisUrl: void 0,
+          redisKeyPrefix: void 0
+        }
+      },
+      dev: {
+        port: DEFAULT_PORT,
+        host: "localhost",
+        open: false
+      },
+      resolve: {
+        importMap: getDefaultImportMapForConfig()
+      },
+      client: {
+        moduleResolution: "cdn",
+        cdn: {
+          provider: "esm.sh",
+          versions: "auto"
+        }
+      }
+    };
+    configCacheByProject = /* @__PURE__ */ new Map();
+    cacheRevision = 0;
+    ConfigValidationError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ConfigValidationError";
+      }
+    };
+  }
+});
+
+// src/core/config/define-config.ts
+function defineConfig(config) {
+  return config;
+}
+var init_define_config = __esm({
+  "src/core/config/define-config.ts"() {
+    "use strict";
+    init_deno_env();
+    init_veryfront_error();
+    init_process();
+  }
 });
 
 // src/core/config/network-defaults.ts
@@ -2327,7 +3261,7 @@ var init_deno2 = __esm({
 });
 
 // src/platform/adapters/shared-watcher.ts
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 async function setupNodeFsWatcher(path, options) {
   try {
     const fs = await import("node:fs");
@@ -2339,7 +3273,7 @@ async function setupNodeFsWatcher(path, options) {
       if (options.closed() || options.signal?.aborted)
         return;
       const kind = eventType === "change" ? "modify" : "any";
-      const fullPath = filename ? join3(path, filename) : path;
+      const fullPath = filename ? join5(path, filename) : path;
       enqueueWatchEvent(
         { kind, paths: [fullPath] },
         options.eventQueue,
@@ -2469,9 +3403,9 @@ var init_filesystem_adapter = __esm({
       }
       async makeTempDir(prefix) {
         const { mkdtemp } = await import("node:fs/promises");
-        const { join: join8 } = await import("node:path");
+        const { join: join10 } = await import("node:path");
         const { tmpdir } = await import("node:os");
-        return await mkdtemp(join8(tmpdir(), prefix));
+        return await mkdtemp(join10(tmpdir(), prefix));
       }
       watch(paths, options) {
         const pathArray = Array.isArray(paths) ? paths : [paths];
@@ -2552,9 +3486,9 @@ var init_environment_adapter = __esm({
   }
 });
 
-// ../node_modules/ws/lib/constants.js
+// ../../node_modules/ws/lib/constants.js
 var require_constants = __commonJS({
-  "../node_modules/ws/lib/constants.js"(exports, module) {
+  "../../node_modules/ws/lib/constants.js"(exports, module) {
     "use strict";
     init_deno_env();
     var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
@@ -2576,9 +3510,9 @@ var require_constants = __commonJS({
   }
 });
 
-// ../node_modules/ws/lib/buffer-util.js
+// ../../node_modules/ws/lib/buffer-util.js
 var require_buffer_util = __commonJS({
-  "../node_modules/ws/lib/buffer-util.js"(exports, module) {
+  "../../node_modules/ws/lib/buffer-util.js"(exports, module) {
     "use strict";
     init_deno_env();
     var { EMPTY_BUFFER } = require_constants();
@@ -2659,9 +3593,9 @@ var require_buffer_util = __commonJS({
   }
 });
 
-// ../node_modules/ws/lib/limiter.js
+// ../../node_modules/ws/lib/limiter.js
 var require_limiter = __commonJS({
-  "../node_modules/ws/lib/limiter.js"(exports, module) {
+  "../../node_modules/ws/lib/limiter.js"(exports, module) {
     "use strict";
     init_deno_env();
     var kDone = Symbol("kDone");
@@ -2711,9 +3645,9 @@ var require_limiter = __commonJS({
   }
 });
 
-// ../node_modules/ws/lib/permessage-deflate.js
+// ../../node_modules/ws/lib/permessage-deflate.js
 var require_permessage_deflate = __commonJS({
-  "../node_modules/ws/lib/permessage-deflate.js"(exports, module) {
+  "../../node_modules/ws/lib/permessage-deflate.js"(exports, module) {
     "use strict";
     init_deno_env();
     var zlib = __require2("zlib");
@@ -3096,9 +4030,9 @@ var require_permessage_deflate = __commonJS({
   }
 });
 
-// ../node_modules/ws/lib/validation.js
+// ../../node_modules/ws/lib/validation.js
 var require_validation = __commonJS({
-  "../node_modules/ws/lib/validation.js"(exports, module) {
+  "../../node_modules/ws/lib/validation.js"(exports, module) {
     "use strict";
     init_deno_env();
     var { isUtf8 } = __require2("buffer");
@@ -3298,9 +4232,9 @@ var require_validation = __commonJS({
   }
 });
 
-// ../node_modules/ws/lib/receiver.js
+// ../../node_modules/ws/lib/receiver.js
 var require_receiver = __commonJS({
-  "../node_modules/ws/lib/receiver.js"(exports, module) {
+  "../../node_modules/ws/lib/receiver.js"(exports, module) {
     "use strict";
     init_deno_env();
     var { Writable } = __require2("stream");
@@ -3902,9 +4836,9 @@ var require_receiver = __commonJS({
   }
 });
 
-// ../node_modules/ws/lib/sender.js
+// ../../node_modules/ws/lib/sender.js
 var require_sender = __commonJS({
-  "../node_modules/ws/lib/sender.js"(exports, module) {
+  "../../node_modules/ws/lib/sender.js"(exports, module) {
     "use strict";
     init_deno_env();
     var { Duplex } = __require2("stream");
@@ -4397,9 +5331,9 @@ var require_sender = __commonJS({
   }
 });
 
-// ../node_modules/ws/lib/event-target.js
+// ../../node_modules/ws/lib/event-target.js
 var require_event_target = __commonJS({
-  "../node_modules/ws/lib/event-target.js"(exports, module) {
+  "../../node_modules/ws/lib/event-target.js"(exports, module) {
     "use strict";
     init_deno_env();
     var { kForOnEventAttribute, kListener } = require_constants();
@@ -4627,9 +5561,9 @@ var require_event_target = __commonJS({
   }
 });
 
-// ../node_modules/ws/lib/extension.js
+// ../../node_modules/ws/lib/extension.js
 var require_extension = __commonJS({
-  "../node_modules/ws/lib/extension.js"(exports, module) {
+  "../../node_modules/ws/lib/extension.js"(exports, module) {
     "use strict";
     init_deno_env();
     var { tokenChars } = require_validation();
@@ -4639,7 +5573,7 @@ var require_extension = __commonJS({
       else
         dest[name].push(elem);
     }
-    function parse(header) {
+    function parse2(header) {
       const offers = /* @__PURE__ */ Object.create(null);
       let params = /* @__PURE__ */ Object.create(null);
       let mustUnescape = false;
@@ -4794,13 +5728,13 @@ var require_extension = __commonJS({
         }).join(", ");
       }).join(", ");
     }
-    module.exports = { format, parse };
+    module.exports = { format, parse: parse2 };
   }
 });
 
-// ../node_modules/ws/lib/websocket.js
+// ../../node_modules/ws/lib/websocket.js
 var require_websocket = __commonJS({
-  "../node_modules/ws/lib/websocket.js"(exports, module) {
+  "../../node_modules/ws/lib/websocket.js"(exports, module) {
     "use strict";
     init_deno_env();
     var EventEmitter = __require2("events");
@@ -4828,7 +5762,7 @@ var require_websocket = __commonJS({
     var {
       EventTarget: { addEventListener, removeEventListener }
     } = require_event_target();
-    var { format, parse } = require_extension();
+    var { format, parse: parse2 } = require_extension();
     var { toBuffer } = require_buffer_util();
     var closeTimeout = 30 * 1e3;
     var kAborted = Symbol("kAborted");
@@ -5516,7 +6450,7 @@ var require_websocket = __commonJS({
           }
           let extensions;
           try {
-            extensions = parse(secWebSocketExtensions);
+            extensions = parse2(secWebSocketExtensions);
           } catch (err) {
             const message = "Invalid Sec-WebSocket-Extensions header";
             abortHandshake(websocket, socket, message);
@@ -5711,9 +6645,9 @@ var require_websocket = __commonJS({
   }
 });
 
-// ../node_modules/ws/lib/stream.js
+// ../../node_modules/ws/lib/stream.js
 var require_stream = __commonJS({
-  "../node_modules/ws/lib/stream.js"(exports, module) {
+  "../../node_modules/ws/lib/stream.js"(exports, module) {
     "use strict";
     init_deno_env();
     var WebSocket2 = require_websocket();
@@ -5818,13 +6752,13 @@ var require_stream = __commonJS({
   }
 });
 
-// ../node_modules/ws/lib/subprotocol.js
+// ../../node_modules/ws/lib/subprotocol.js
 var require_subprotocol = __commonJS({
-  "../node_modules/ws/lib/subprotocol.js"(exports, module) {
+  "../../node_modules/ws/lib/subprotocol.js"(exports, module) {
     "use strict";
     init_deno_env();
     var { tokenChars } = require_validation();
-    function parse(header) {
+    function parse2(header) {
       const protocols = /* @__PURE__ */ new Set();
       let start = -1;
       let end = -1;
@@ -5863,13 +6797,13 @@ var require_subprotocol = __commonJS({
       protocols.add(protocol);
       return protocols;
     }
-    module.exports = { parse };
+    module.exports = { parse: parse2 };
   }
 });
 
-// ../node_modules/ws/lib/websocket-server.js
+// ../../node_modules/ws/lib/websocket-server.js
 var require_websocket_server = __commonJS({
-  "../node_modules/ws/lib/websocket-server.js"(exports, module) {
+  "../../node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
     init_deno_env();
     var EventEmitter = __require2("events");
@@ -6266,7 +7200,7 @@ var require_websocket_server = __commonJS({
   }
 });
 
-// ../node_modules/ws/wrapper.mjs
+// ../../node_modules/ws/wrapper.mjs
 var wrapper_exports = {};
 __export(wrapper_exports, {
   Receiver: () => import_receiver.default,
@@ -6278,7 +7212,7 @@ __export(wrapper_exports, {
 });
 var import_stream, import_receiver, import_sender, import_websocket, import_websocket_server, wrapper_default;
 var init_wrapper = __esm({
-  "../node_modules/ws/wrapper.mjs"() {
+  "../../node_modules/ws/wrapper.mjs"() {
     init_deno_env();
     import_stream = __toESM(require_stream(), 1);
     import_receiver = __toESM(require_receiver(), 1);
@@ -6732,6 +7666,15 @@ var init_error_handlers = __esm({
   }
 });
 
+// src/core/errors/error-context.ts
+var init_error_context = __esm({
+  "src/core/errors/error-context.ts"() {
+    "use strict";
+    init_deno_env();
+    init_logger();
+  }
+});
+
 // src/core/errors/error-codes.ts
 function getErrorDocsUrl(code) {
   return `https://veryfront.com/docs/errors/${code}`;
@@ -7894,6 +8837,7 @@ var init_errors = __esm({
     init_runtime_errors();
     init_system_errors();
     init_error_handlers();
+    init_error_context();
     init_catalog();
     init_user_friendly();
   }
@@ -7964,9 +8908,9 @@ var init_filesystem_adapter2 = __esm({
       }
       async makeTempDir(prefix) {
         const { mkdtemp } = await import("node:fs/promises");
-        const { join: join8 } = await import("node:path");
+        const { join: join10 } = await import("node:path");
         const { tmpdir } = await import("node:os");
-        return await mkdtemp(join8(tmpdir(), prefix));
+        return await mkdtemp(join10(tmpdir(), prefix));
       }
       watch(paths, options) {
         const pathArray = Array.isArray(paths) ? paths : [paths];
@@ -8557,7 +9501,7 @@ __export(detect_exports, {
   runtime: () => runtime
 });
 function isDeno2(global) {
-  return "Deno" in global && typeof global.Deno === "object";
+  return "Deno" in global && typeof global.Deno === "object" && typeof global.Deno.version === "object";
 }
 function isBun2(global) {
   return "Bun" in global && typeof global.Bun === "object";
@@ -9057,6 +10001,9 @@ var LRUCache = class {
       this.adapter.cleanupExpired();
     }, this.cleanupIntervalMs);
     this.cleanupTimer = timer;
+    if (typeof Deno !== "undefined" && "unrefTimer" in Deno) {
+      Deno.unrefTimer(timer);
+    }
   }
   toStringKey(key) {
     if (typeof key === "string") {
@@ -9134,87 +10081,1748 @@ init_deno_env();
 init_deno_env();
 init_utils();
 init_config();
-import { dirname, join as join2 } from "node:path";
+import { dirname as dirname2, join as join2 } from "node:path";
 
 // src/module-system/import-map/default-import-map.ts
 init_deno_env();
 init_utils();
+init_runtime();
+var IS_TRUE_NODE = isNode && !isDeno;
+function getNpmReactImportMap(version) {
+  return {
+    react: `npm:react@${version}`,
+    "react-dom": `npm:react-dom@${version}`,
+    "react-dom/client": `npm:react-dom@${version}/client`,
+    "react-dom/server": `npm:react-dom@${version}/server`,
+    "react/jsx-runtime": `npm:react@${version}/jsx-runtime`,
+    "react/jsx-dev-runtime": `npm:react@${version}/jsx-dev-runtime`,
+    "react/": `npm:react@${version}/`
+  };
+}
 function getDefaultImportMap() {
   const reactVersion = REACT_DEFAULT_VERSION;
+  if (!IS_TRUE_NODE) {
+    return { imports: getNpmReactImportMap(reactVersion) };
+  }
   const importMap = getReactImportMap(reactVersion);
   importMap["react/"] = `https://esm.sh/react@${reactVersion}/`;
   return { imports: importMap };
 }
-
-// src/module-system/import-map/resolver.ts
-init_deno_env();
-function resolveImport(specifier, importMap, scope) {
-  if (scope && importMap.scopes?.[scope]?.[specifier]) {
-    return importMap.scopes[scope][specifier];
+
+// src/module-system/import-map/resolver.ts
+init_deno_env();
+function resolveImport(specifier, importMap, scope) {
+  if (scope && importMap.scopes?.[scope]?.[specifier]) {
+    return importMap.scopes[scope][specifier];
+  }
+  if (importMap.imports?.[specifier]) {
+    return importMap.imports[specifier];
+  }
+  if (specifier.endsWith(".js") || specifier.endsWith(".mjs") || specifier.endsWith(".cjs")) {
+    const base = specifier.replace(/\.(m|c)?js$/, "");
+    if (importMap.imports?.[base]) {
+      return importMap.imports[base];
+    }
+  }
+  if (importMap.imports) {
+    for (const [key, value] of Object.entries(importMap.imports)) {
+      if (key.endsWith("/") && specifier.startsWith(key)) {
+        return value + specifier.slice(key.length);
+      }
+    }
+  }
+  return specifier;
+}
+
+// src/module-system/import-map/transformer.ts
+init_deno_env();
+function transformImportsWithMap(code, importMap, scope, options) {
+  let transformedCode = code;
+  transformedCode = transformedCode.replace(
+    /((?:import|export)\s+(?:[\w,{}\s*]+\s+from\s+)?|export\s+(?:\*|\{[^}]+\})\s+from\s+)["']([^"']+)["']/g,
+    (_match, prefix, specifier) => {
+      const isBare = !specifier.startsWith("http") && !specifier.startsWith("/") && !specifier.startsWith(".");
+      if (isBare && !options?.resolveBare) {
+        return `${prefix}"${specifier}"`;
+      }
+      const resolved = resolveImport(specifier, importMap, scope);
+      return `${prefix}"${resolved}"`;
+    }
+  );
+  transformedCode = transformedCode.replace(
+    /from\s+["']([^"']+)["']/g,
+    (match, specifier) => {
+      const isBare = !specifier.startsWith("http") && !specifier.startsWith("/") && !specifier.startsWith(".");
+      if (isBare && !options?.resolveBare) {
+        return match;
+      }
+      const resolved = resolveImport(specifier, importMap, scope);
+      return `from "${resolved}"`;
+    }
+  );
+  transformedCode = transformedCode.replace(
+    /import\s*\(\s*["']([^"']+)["']\s*\)/g,
+    (_match, specifier) => {
+      const resolved = resolveImport(specifier, importMap, scope);
+      return `import("${resolved}")`;
+    }
+  );
+  return transformedCode;
+}
+
+// src/module-system/import-map/merger.ts
+init_deno_env();
+
+// src/build/transforms/mdx/esm-module-loader.ts
+init_runtime();
+init_process();
+import { join as join6, posix } from "node:path";
+
+// src/build/transforms/esm-transform.ts
+init_deno_env();
+
+// src/build/transforms/esm/index.ts
+init_deno_env();
+
+// src/build/transforms/esm/transform-core.ts
+init_deno_env();
+import * as esbuild from "esbuild/mod.js";
+
+// src/build/transforms/esm/transform-cache.ts
+init_deno_env();
+
+// src/core/memory/index.ts
+init_deno_env();
+
+// src/core/memory/profiler.ts
+init_deno_env();
+init_utils();
+var cacheRegistry = /* @__PURE__ */ new Map();
+function registerCache(name, getStats) {
+  cacheRegistry.set(name, getStats);
+  rendererLogger.debug(`[MemoryProfiler] Registered cache: ${name}`);
+}
+
+// src/build/transforms/esm/transform-cache.ts
+init_logger();
+
+// src/core/utils/redis-client.ts
+init_deno_env();
+init_logger();
+
+// src/build/transforms/esm/transform-cache.ts
+var DEFAULT_TTL_MS = 5 * 60 * 1e3;
+var DEFAULT_TTL_SECONDS = 300;
+var MAX_ENTRIES = 2e3;
+var CLEANUP_INTERVAL_MS = 6e4;
+var REDIS_KEY_PREFIX = "veryfront:transform:";
+var memoryCache = /* @__PURE__ */ new Map();
+var redisEnabled = false;
+var redisClient = null;
+registerCache("transform-cache", () => ({
+  name: "transform-cache",
+  entries: memoryCache.size,
+  maxEntries: MAX_ENTRIES,
+  redisEnabled
+}));
+var cleanupInterval;
+function shouldDisableInterval2() {
+  if (globalThis.__vfDisableLruInterval === true) {
+    return true;
+  }
+  try {
+    if (typeof Deno !== "undefined" && Deno.env) {
+      return Deno.env.get("VF_DISABLE_LRU_INTERVAL") === "1";
+    }
+  } catch {
+  }
+  return false;
+}
+function startPeriodicCleanup() {
+  if (shouldDisableInterval2()) {
+    return;
+  }
+  if (cleanupInterval)
+    return;
+  cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of memoryCache) {
+      if (entry.expiresAt <= now) {
+        memoryCache.delete(key);
+      }
+    }
+  }, CLEANUP_INTERVAL_MS);
+  if (typeof Deno !== "undefined" && "unrefTimer" in Deno) {
+    Deno.unrefTimer(cleanupInterval);
+  }
+}
+startPeriodicCleanup();
+function generateCacheKey(projectId, filePath, contentHash, ssr = false) {
+  const projectKey = projectId?.trim() || "default";
+  const ssrKey = ssr ? "ssr" : "browser";
+  return `${projectKey}:${filePath}:${contentHash}:${ssrKey}`;
+}
+function redisKey(key) {
+  return `${REDIS_KEY_PREFIX}${key}`;
+}
+function getCachedTransform(key) {
+  const entry = memoryCache.get(key);
+  if (!entry) {
+    return void 0;
+  }
+  if (entry.expiresAt <= Date.now()) {
+    memoryCache.delete(key);
+    return void 0;
+  }
+  return entry;
+}
+function setCachedTransform(key, code, hash, ttl = DEFAULT_TTL_MS) {
+  const now = Date.now();
+  memoryCache.set(key, {
+    code,
+    hash,
+    timestamp: now,
+    expiresAt: now + Math.max(1, ttl)
+  });
+  if (memoryCache.size > MAX_ENTRIES) {
+    pruneMemoryCache();
+  }
+  if (redisEnabled && redisClient) {
+    const entry = {
+      code,
+      hash,
+      timestamp: now,
+      expiresAt: now + Math.max(1, ttl)
+    };
+    const ttlSeconds = Math.ceil(ttl / 1e3);
+    redisClient.set(redisKey(key), JSON.stringify(entry), {
+      EX: ttlSeconds > 0 ? ttlSeconds : DEFAULT_TTL_SECONDS
+    }).catch((error2) => {
+      logger.debug("[TransformCache] Redis set failed", { key, error: error2 });
+    });
+  }
+}
+function pruneMemoryCache() {
+  const entries = Array.from(memoryCache.entries()).sort(
+    ([, a], [, b]) => a.timestamp - b.timestamp
+  );
+  const excess = memoryCache.size - MAX_ENTRIES;
+  for (let i = 0; i < excess; i++) {
+    const [key] = entries[i];
+    memoryCache.delete(key);
+  }
+}
+
+// src/build/transforms/esm/transform-utils.ts
+init_deno_env();
+init_hash_utils();
+function computeContentHash2(content) {
+  return shortHash(content);
+}
+function getLoaderFromPath(filePath) {
+  if (filePath.endsWith(".tsx"))
+    return "tsx";
+  if (filePath.endsWith(".ts"))
+    return "ts";
+  if (filePath.endsWith(".jsx"))
+    return "jsx";
+  if (filePath.endsWith(".js"))
+    return "js";
+  if (filePath.endsWith(".mdx"))
+    return "jsx";
+  return "tsx";
+}
+
+// src/build/transforms/esm/react-imports.ts
+init_deno_env();
+
+// src/build/transforms/esm/lexer.ts
+init_deno_env();
+
+// node_modules/.deno/es-module-lexer@1.5.0/node_modules/es-module-lexer/dist/lexer.js
+init_deno_env();
+var ImportType;
+!function(A2) {
+  A2[A2.Static = 1] = "Static", A2[A2.Dynamic = 2] = "Dynamic", A2[A2.ImportMeta = 3] = "ImportMeta", A2[A2.StaticSourcePhase = 4] = "StaticSourcePhase", A2[A2.DynamicSourcePhase = 5] = "DynamicSourcePhase";
+}(ImportType || (ImportType = {}));
+var A = 1 === new Uint8Array(new Uint16Array([1]).buffer)[0];
+function parse(E2, g = "@") {
+  if (!C)
+    return init.then(() => parse(E2));
+  const I = E2.length + 1, w = (C.__heap_base.value || C.__heap_base) + 4 * I - C.memory.buffer.byteLength;
+  w > 0 && C.memory.grow(Math.ceil(w / 65536));
+  const D = C.sa(I - 1);
+  if ((A ? B : Q)(E2, new Uint16Array(C.memory.buffer, D, I)), !C.parse())
+    throw Object.assign(new Error(`Parse error ${g}:${E2.slice(0, C.e()).split("\n").length}:${C.e() - E2.lastIndexOf("\n", C.e() - 1)}`), { idx: C.e() });
+  const o = [], K = [];
+  for (; C.ri(); ) {
+    const A2 = C.is(), Q2 = C.ie(), B2 = C.it(), g2 = C.ai(), I2 = C.id(), w2 = C.ss(), D2 = C.se();
+    let K2;
+    C.ip() && (K2 = k(E2.slice(-1 === I2 ? A2 - 1 : A2, -1 === I2 ? Q2 + 1 : Q2))), o.push({ n: K2, t: B2, s: A2, e: Q2, ss: w2, se: D2, d: I2, a: g2 });
+  }
+  for (; C.re(); ) {
+    const A2 = C.es(), Q2 = C.ee(), B2 = C.els(), g2 = C.ele(), I2 = E2.slice(A2, Q2), w2 = I2[0], D2 = B2 < 0 ? void 0 : E2.slice(B2, g2), o2 = D2 ? D2[0] : "";
+    K.push({ s: A2, e: Q2, ls: B2, le: g2, n: '"' === w2 || "'" === w2 ? k(I2) : I2, ln: '"' === o2 || "'" === o2 ? k(D2) : D2 });
+  }
+  function k(A2) {
+    try {
+      return (0, eval)(A2);
+    } catch (A3) {
+    }
+  }
+  return [o, K, !!C.f(), !!C.ms()];
+}
+function Q(A2, Q2) {
+  const B2 = A2.length;
+  let C2 = 0;
+  for (; C2 < B2; ) {
+    const B3 = A2.charCodeAt(C2);
+    Q2[C2++] = (255 & B3) << 8 | B3 >>> 8;
+  }
+}
+function B(A2, Q2) {
+  const B2 = A2.length;
+  let C2 = 0;
+  for (; C2 < B2; )
+    Q2[C2] = A2.charCodeAt(C2++);
+}
+var C;
+var init = WebAssembly.compile((E = "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", "undefined" != typeof Buffer ? Buffer.from(E, "base64") : Uint8Array.from(atob(E), (A2) => A2.charCodeAt(0)))).then(WebAssembly.instantiate).then(({ exports: A2 }) => {
+  C = A2;
+});
+var E;
+
+// src/build/transforms/esm/lexer.ts
+var initPromise = null;
+async function initLexer() {
+  if (!initPromise) {
+    const anyInit = init;
+    initPromise = typeof anyInit === "function" ? anyInit() : anyInit;
+  }
+  await initPromise;
+}
+async function parseImports(code) {
+  await initLexer();
+  return parse(code)[0];
+}
+async function replaceSpecifiers(code, replacer) {
+  const imports = await parseImports(code);
+  let result = code;
+  for (let i = imports.length - 1; i >= 0; i--) {
+    const imp = imports[i];
+    if (!imp)
+      continue;
+    if (imp.n === void 0)
+      continue;
+    const replacement = replacer(imp.n, imp.d > -1);
+    if (replacement && replacement !== imp.n) {
+      const before = result.substring(0, imp.s);
+      const after = result.substring(imp.e);
+      result = before + replacement + after;
+    }
+  }
+  return result;
+}
+async function rewriteImports(code, rewriter) {
+  const imports = await parseImports(code);
+  let result = code;
+  for (let i = imports.length - 1; i >= 0; i--) {
+    const imp = imports[i];
+    if (!imp)
+      continue;
+    const statement = code.substring(imp.ss, imp.se);
+    const replacement = rewriter(imp, statement);
+    if (replacement !== null) {
+      const before = result.substring(0, imp.ss);
+      const after = result.substring(imp.se);
+      result = before + replacement + after;
+    }
+  }
+  return result;
+}
+
+// src/build/transforms/esm/react-imports.ts
+init_cdn();
+init_runtime();
+init_process();
+function getVeryfrontAIReactPath(subpath = "") {
+  const currentDir = new URL(".", import.meta.url).pathname;
+  const srcDir = currentDir.replace(/\/build\/transforms\/esm\/?$/, "");
+  const modulePath = subpath || "index.ts";
+  return `file://${srcDir}/ai/react/${modulePath}`;
+}
+var projectHasReactDom = null;
+async function checkProjectHasReactDom() {
+  if (projectHasReactDom !== null) {
+    return projectHasReactDom;
+  }
+  if (!isNodeRuntime()) {
+    projectHasReactDom = false;
+    return false;
+  }
+  try {
+    const { createRequire } = await import("node:module");
+    const { pathToFileURL } = await import("node:url");
+    const projectRequire = createRequire(pathToFileURL(cwd() + "/").href);
+    projectRequire.resolve("react");
+    projectRequire.resolve("react-dom/server");
+    projectHasReactDom = true;
+    return true;
+  } catch {
+    projectHasReactDom = false;
+    return false;
+  }
+}
+async function getBundledReactPath(subpath = "") {
+  if (!isNodeRuntime()) {
+    return null;
+  }
+  try {
+    const { createRequire } = await import("node:module");
+    const cliRequire = createRequire(import.meta.url);
+    const moduleName = subpath ? `react${subpath}` : "react";
+    return cliRequire.resolve(moduleName);
+  } catch {
+    return null;
+  }
+}
+async function resolveReactImports(code, forSSR = false) {
+  const isNode2 = isNodeRuntime();
+  if (isNode2 && forSSR) {
+    const hasReactDom = await checkProjectHasReactDom();
+    const { pathToFileURL } = await import("node:url");
+    if (hasReactDom) {
+      try {
+        const { createRequire } = await import("node:module");
+        const projectRequire = createRequire(pathToFileURL(cwd() + "/").href);
+        const projectImports = {
+          "react/jsx-runtime": pathToFileURL(projectRequire.resolve("react/jsx-runtime")).href,
+          "react/jsx-dev-runtime": pathToFileURL(projectRequire.resolve("react/jsx-dev-runtime")).href,
+          "react": pathToFileURL(projectRequire.resolve("react")).href
+        };
+        return replaceSpecifiers(code, (specifier) => {
+          return projectImports[specifier] || null;
+        });
+      } catch {
+      }
+    }
+    const bundledReact = await getBundledReactPath();
+    const bundledJsxRuntime = await getBundledReactPath("/jsx-runtime");
+    const bundledJsxDevRuntime = await getBundledReactPath("/jsx-dev-runtime");
+    if (bundledReact && bundledJsxRuntime && bundledJsxDevRuntime) {
+      const bundledImports = {
+        "react/jsx-runtime": pathToFileURL(bundledJsxRuntime).href,
+        "react/jsx-dev-runtime": pathToFileURL(bundledJsxDevRuntime).href,
+        "react": pathToFileURL(bundledReact).href
+      };
+      return replaceSpecifiers(code, (specifier) => {
+        return bundledImports[specifier] || null;
+      });
+    }
+    return code;
+  }
+  if (isNode2) {
+    return code;
+  }
+  if (forSSR) {
+    const denoSSRImports = {
+      "veryfront/ai/react": getVeryfrontAIReactPath(),
+      "veryfront/ai/components": getVeryfrontAIReactPath("components/index.ts"),
+      "veryfront/ai/primitives": getVeryfrontAIReactPath("primitives/index.ts")
+    };
+    return replaceSpecifiers(code, (specifier) => {
+      return denoSSRImports[specifier] || null;
+    });
+  }
+  const reactImports = {
+    "react/jsx-runtime": `https://esm.sh/react@${REACT_DEFAULT_VERSION}/jsx-runtime`,
+    "react/jsx-dev-runtime": `https://esm.sh/react@${REACT_DEFAULT_VERSION}/jsx-dev-runtime`,
+    "react-dom/server": `https://esm.sh/react-dom@${REACT_DEFAULT_VERSION}/server`,
+    "react-dom/client": `https://esm.sh/react-dom@${REACT_DEFAULT_VERSION}/client`,
+    "react-dom": `https://esm.sh/react-dom@${REACT_DEFAULT_VERSION}`,
+    "react": `https://esm.sh/react@${REACT_DEFAULT_VERSION}`
+  };
+  return replaceSpecifiers(code, (specifier) => {
+    return reactImports[specifier] || null;
+  });
+}
+function addDepsToEsmShUrls(code, forSSR = false) {
+  if (isNodeRuntime()) {
+    return Promise.resolve(code);
+  }
+  return Promise.resolve(replaceSpecifiers(code, (specifier) => {
+    if (specifier.startsWith("https://esm.sh/") && !specifier.includes(`react@${REACT_DEFAULT_VERSION}`)) {
+      const hasQuery = specifier.includes("?");
+      const hasExternal = specifier.includes("external=");
+      if (forSSR) {
+        if (hasExternal) {
+          return null;
+        }
+        const separator = hasQuery ? "&" : "?";
+        return `${specifier}${separator}external=react,react-dom`;
+      } else {
+        if (hasQuery) {
+          return null;
+        }
+        return `${specifier}?deps=react@${REACT_DEFAULT_VERSION},react-dom@${REACT_DEFAULT_VERSION}`;
+      }
+    }
+    return null;
+  }));
+}
+
+// src/build/transforms/esm/path-resolver.ts
+init_deno_env();
+init_cdn();
+init_utils();
+import { join as join3 } from "node:path";
+import { ensureDir } from "node:fs";
+var SSR_STUBS_DIR = join3(
+  Deno.env.get("HOME") || "/tmp",
+  ".cache",
+  "veryfront-ssr-stubs"
+);
+var stubFileCache = /* @__PURE__ */ new Map();
+function extractNamedImports(statement) {
+  const namedImports = [];
+  const braceMatch = statement.match(/\{([^}]+)\}/);
+  if (braceMatch) {
+    const inside = braceMatch[1];
+    const parts = inside.split(",");
+    for (const part of parts) {
+      const trimmed = part.trim();
+      if (!trimmed)
+        continue;
+      const asMatch = trimmed.match(/^(\w+)\s+as\s+\w+$/);
+      if (asMatch) {
+        namedImports.push(asMatch[1]);
+      } else {
+        namedImports.push(trimmed);
+      }
+    }
+  }
+  return namedImports;
+}
+var CROSS_PROJECT_VERSIONED_PATTERN = /^([a-z0-9-]+)@([\d^~x][\d.x^~-]*)\/@\/(.+)$/;
+var CROSS_PROJECT_LATEST_PATTERN = /^([a-z0-9-]+)\/@\/(.+)$/;
+function parseCrossProjectImport(specifier) {
+  const versionedMatch = specifier.match(CROSS_PROJECT_VERSIONED_PATTERN);
+  if (versionedMatch) {
+    return {
+      projectSlug: versionedMatch[1],
+      version: versionedMatch[2],
+      path: versionedMatch[3]
+    };
+  }
+  const latestMatch = specifier.match(CROSS_PROJECT_LATEST_PATTERN);
+  if (latestMatch) {
+    return {
+      projectSlug: latestMatch[1],
+      version: "latest",
+      path: latestMatch[2]
+    };
+  }
+  return null;
+}
+function resolveCrossProjectImports(code, options) {
+  const { ssr = false } = options;
+  if (ssr) {
+    return Promise.resolve(code);
+  }
+  return Promise.resolve(
+    replaceSpecifiers(code, (specifier) => {
+      const parsed = parseCrossProjectImport(specifier);
+      if (!parsed)
+        return null;
+      const { projectSlug, version, path } = parsed;
+      let modulePath = path;
+      if (!/\.(js|mjs|jsx|ts|tsx|mdx)$/.test(modulePath)) {
+        modulePath = `${modulePath}.tsx`;
+      }
+      const projectRef = version === "latest" ? projectSlug : `${projectSlug}@${version}`;
+      const moduleServerUrl = `/_vf_modules/_cross/${projectRef}/@/${modulePath}`;
+      rendererLogger.debug("[CrossProjectImport] Rewriting", { from: specifier, to: moduleServerUrl });
+      return moduleServerUrl;
+    })
+  );
+}
+async function hashUrl(url) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(url);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.slice(0, 8).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function getOrCreateStubFile(specifier, namedExports = []) {
+  const sortedExports = [...namedExports].sort();
+  const cacheKey = `${specifier}::${sortedExports.join(",")}`;
+  const cached = stubFileCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const namedExportDeclarations = namedExports.map((name) => {
+    if (/^[A-Z]/.test(name) || name.endsWith("Provider") || name.endsWith("Consumer")) {
+      return `export const ${name} = noopComponent;`;
+    }
+    if (name.startsWith("use")) {
+      return `export const ${name} = () => ({});`;
+    }
+    if (["clsx", "cn", "twMerge", "twJoin", "cx", "classNames", "classnames"].includes(name)) {
+      return `export const ${name} = (...args) => args.filter(Boolean).join(" ");`;
+    }
+    if (name === "cva") {
+      return `export const ${name} = (base, _config) => (_props) => base || "";`;
+    }
+    if (name === "motion" || name === "m") {
+      return `export const ${name} = motionProxy;`;
+    }
+    if (name === "AnimatePresence") {
+      return `export const ${name} = noopComponent;`;
+    }
+    return `export const ${name} = noop;`;
+  }).join("\n");
+  const stubModule = `// SSR stub for ${specifier}
+// Named exports: ${namedExports.join(", ") || "(none)"}
+const noop = () => {};
+const noopComponent = (props) => props?.children || null;
+
+// Proxy for motion-like APIs (motion.div, motion.span, etc.)
+const motionProxy = new Proxy(noopComponent, {
+  get(_, prop) {
+    if (prop === 'default' || prop === '__esModule') return motionProxy;
+    // motion.div, motion.span, etc. should return a component
+    return noopComponent;
+  }
+});
+
+const noopProxy = new Proxy(function(){}, {
+  get(_, prop) {
+    if (prop === 'default' || prop === '__esModule') return noopProxy;
+    if (prop === 'Provider' || prop === 'Consumer') return noopComponent;
+    if (typeof prop === 'string' && prop.startsWith('use')) return () => ({});
+    return noop;
+  },
+  apply() { return null; }
+});
+
+// Named exports
+${namedExportDeclarations}
+
+// Default export and metadata
+export default noopProxy;
+export const __ssr_stub__ = true;
+export const __original_url__ = ${JSON.stringify(specifier)};
+`;
+  const hash = await hashUrl(cacheKey);
+  const stubPath = join3(SSR_STUBS_DIR, `stub-${hash}.js`);
+  await ensureDir(SSR_STUBS_DIR);
+  await Deno.writeTextFile(stubPath, stubModule);
+  try {
+    await import(`file://${stubPath}`);
+  } catch {
+  }
+  stubFileCache.set(cacheKey, stubPath);
+  return stubPath;
+}
+async function blockExternalUrlImports(code, _filePath) {
+  const blockedUrls = [];
+  const imports = await parseImports(code);
+  const urlToNamedExports = /* @__PURE__ */ new Map();
+  for (const imp of imports) {
+    if (imp.n && (imp.n.startsWith("https://") || imp.n.startsWith("http://"))) {
+      blockedUrls.push(imp.n);
+      const statement = code.substring(imp.ss, imp.se);
+      const namedExports = extractNamedImports(statement);
+      const existing = urlToNamedExports.get(imp.n) || [];
+      urlToNamedExports.set(imp.n, [.../* @__PURE__ */ new Set([...existing, ...namedExports])]);
+    }
+  }
+  if (blockedUrls.length === 0) {
+    return { code, blockedUrls };
+  }
+  const stubPaths = /* @__PURE__ */ new Map();
+  for (const [url, namedExports] of urlToNamedExports) {
+    const stubPath = await getOrCreateStubFile(url, namedExports);
+    stubPaths.set(url, stubPath);
+  }
+  const transformedCode = await replaceSpecifiers(code, (specifier) => {
+    if (specifier.startsWith("https://") || specifier.startsWith("http://")) {
+      const stubPath = stubPaths.get(specifier);
+      if (stubPath) {
+        return `file://${stubPath}`;
+      }
+    }
+    return null;
+  });
+  return { code: transformedCode, blockedUrls };
+}
+function resolveVeryfrontImports(code) {
+  return Promise.resolve(replaceSpecifiers(code, (specifier) => {
+    if (specifier.startsWith("@veryfront/")) {
+      return specifier.replace("@veryfront/", "veryfront/");
+    }
+    if (specifier === "@veryfront") {
+      return "veryfront";
+    }
+    return null;
+  }));
+}
+function resolvePathAliases(code, filePath, projectDir, ssr = false) {
+  const _normalizedProjectDir = projectDir.replace(/\\/g, "/").replace(/\/$/, "");
+  let relativeFilePath = filePath;
+  if (filePath.startsWith(_normalizedProjectDir)) {
+    relativeFilePath = filePath.substring(_normalizedProjectDir.length + 1);
+  } else if (filePath.startsWith("/")) {
+    const pathParts = filePath.split("/");
+    const projectParts = _normalizedProjectDir.split("/");
+    const lastProjectPart = projectParts[projectParts.length - 1];
+    const projectIndex = pathParts.indexOf(lastProjectPart);
+    if (projectIndex >= 0) {
+      relativeFilePath = pathParts.slice(projectIndex + 1).join("/");
+    }
+  }
+  const fileDir = relativeFilePath.substring(0, relativeFilePath.lastIndexOf("/"));
+  const depth = fileDir.split("/").filter(Boolean).length;
+  const relativeToRoot = depth === 0 ? "." : "../".repeat(depth).slice(0, -1);
+  return Promise.resolve(replaceSpecifiers(code, (specifier) => {
+    if (specifier.startsWith("@/")) {
+      const path = specifier.substring(2);
+      const relativePath = depth === 0 ? `./${path}` : `${relativeToRoot}/${path}`;
+      if (!/\.(tsx?|jsx?|mjs|cjs|mdx)$/.test(relativePath)) {
+        return relativePath + ".js";
+      }
+      if (ssr) {
+        return relativePath.replace(/\.(tsx?|jsx|mdx)$/, ".js");
+      }
+      return relativePath;
+    }
+    return null;
+  }));
+}
+function resolveRelativeImports(code, filePath, projectDir, moduleServerUrl) {
+  const _normalizedProjectDir = projectDir.replace(/\\/g, "/").replace(/\/$/, "");
+  let relativeFilePath = filePath;
+  if (filePath.startsWith(_normalizedProjectDir)) {
+    relativeFilePath = filePath.substring(_normalizedProjectDir.length + 1);
+  } else if (filePath.startsWith("/")) {
+    const pathParts = filePath.split("/");
+    const projectParts = _normalizedProjectDir.split("/");
+    const lastProjectPart = projectParts[projectParts.length - 1];
+    const projectIndex = pathParts.indexOf(lastProjectPart);
+    if (projectIndex >= 0) {
+      relativeFilePath = pathParts.slice(projectIndex + 1).join("/");
+    }
+  }
+  const fileDir = relativeFilePath.substring(0, relativeFilePath.lastIndexOf("/"));
+  return Promise.resolve(replaceSpecifiers(code, (specifier) => {
+    if (specifier.startsWith("./") || specifier.startsWith("../")) {
+      let rewrittenSpecifier = specifier;
+      if (/\.(tsx?|jsx)$/.test(specifier)) {
+        rewrittenSpecifier = specifier.replace(/\.(tsx?|jsx)$/, ".js");
+      }
+      if (moduleServerUrl) {
+        const resolvedPath = resolveRelativePath(fileDir, rewrittenSpecifier);
+        return `${moduleServerUrl}/${resolvedPath}`;
+      }
+      return rewrittenSpecifier;
+    }
+    return null;
+  }));
+}
+function resolveRelativePath(currentDir, importPath) {
+  const currentParts = currentDir.split("/").filter(Boolean);
+  const importParts = importPath.split("/").filter(Boolean);
+  const resolvedParts = [...currentParts];
+  for (const part of importParts) {
+    if (part === "..") {
+      resolvedParts.pop();
+    } else if (part !== ".") {
+      resolvedParts.push(part);
+    }
+  }
+  return resolvedParts.join("/");
+}
+function resolveRelativeImportsForSSR(code) {
+  return Promise.resolve(replaceSpecifiers(code, (specifier) => {
+    if (specifier.startsWith("./") || specifier.startsWith("../")) {
+      if (/\.(js|mjs|cjs)$/.test(specifier)) {
+        return null;
+      }
+      const withoutExt = specifier.replace(/\.(tsx?|jsx|mdx)$/, "");
+      return withoutExt + ".js";
+    }
+    return null;
+  }));
+}
+
+// src/build/transforms/esm/import-rewriter.ts
+init_deno_env();
+init_cdn();
+init_utils();
+var unversionedImportsWarned = /* @__PURE__ */ new Set();
+function hasVersionSpecifier(specifier) {
+  return /@[\d^~x][\d.x^~-]*(?=\/|$)/.test(specifier);
+}
+function warnUnversionedImport(specifier) {
+  if (unversionedImportsWarned.has(specifier)) {
+    return;
+  }
+  unversionedImportsWarned.add(specifier);
+  const suggestedVersion = "x.y.z";
+  const packageName = specifier.split("/")[0];
+  const isScoped = specifier.startsWith("@");
+  const scopedPackage = isScoped ? specifier.split("/").slice(0, 2).join("/") : packageName;
+  const subpath = isScoped ? specifier.split("/").slice(2).join("/") : specifier.split("/").slice(1).join("/");
+  const versionedSpecifier = subpath ? `${scopedPackage}@${suggestedVersion}/${subpath}` : `${scopedPackage}@${suggestedVersion}`;
+  rendererLogger.warn("[ESM] Unversioned import may cause reproducibility issues", {
+    import: specifier,
+    suggestion: `Pin version: import '${versionedSpecifier}'`,
+    help: "Run 'npm info " + (isScoped ? scopedPackage : packageName) + " version' to find current version"
+  });
+}
+function normalizeVersionedSpecifier(specifier) {
+  return specifier.replace(/@[\d^~x][\d.x^~-]*(?=\/|$)/, "");
+}
+function rewriteBareImports(code, _moduleServerUrl) {
+  const importMap = {
+    "react": `https://esm.sh/react@${REACT_DEFAULT_VERSION}`,
+    "react-dom": `https://esm.sh/react-dom@${REACT_DEFAULT_VERSION}`,
+    "react-dom/client": `https://esm.sh/react-dom@${REACT_DEFAULT_VERSION}/client`,
+    "react-dom/server": `https://esm.sh/react-dom@${REACT_DEFAULT_VERSION}/server`,
+    "react/jsx-runtime": `https://esm.sh/react@${REACT_DEFAULT_VERSION}/jsx-runtime`,
+    "react/jsx-dev-runtime": `https://esm.sh/react@${REACT_DEFAULT_VERSION}/jsx-dev-runtime`,
+    // React Query must use same URL as HTML import map to avoid multiple module instances
+    "@tanstack/react-query": `https://esm.sh/@tanstack/react-query@5?external=react`
+    // NOTE: veryfront/ai/react is NOT rewritten here - it's handled by the HTML import map
+    // which points to /_veryfront/lib/ai/react.js served from the local package
+  };
+  return Promise.resolve(replaceSpecifiers(code, (specifier) => {
+    if (importMap[specifier]) {
+      return importMap[specifier];
+    }
+    if (specifier.startsWith("http://") || specifier.startsWith("https://") || specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/") || specifier.startsWith("@/") || // Project alias
+    specifier.startsWith("veryfront")) {
+      return null;
+    }
+    const normalized = normalizeVersionedSpecifier(specifier);
+    let finalSpecifier = normalized;
+    if (normalized === "tailwindcss" || normalized.startsWith("tailwindcss/")) {
+      finalSpecifier = normalized.replace(/^tailwindcss/, `tailwindcss@${TAILWIND_VERSION}`);
+    } else if (!hasVersionSpecifier(specifier)) {
+      warnUnversionedImport(specifier);
+    }
+    return `https://esm.sh/${finalSpecifier}?deps=react@${REACT_DEFAULT_VERSION},react-dom@${REACT_DEFAULT_VERSION}`;
+  }));
+}
+async function rewriteVendorImports(code, moduleServerUrl, vendorBundleHash) {
+  const vendorUrl = `${moduleServerUrl}/_vendor.js?v=${vendorBundleHash}`;
+  const reactPackages = /* @__PURE__ */ new Set([
+    "react",
+    "react-dom",
+    "react-dom/client",
+    "react-dom/server",
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime"
+  ]);
+  let result = await rewriteImports(code, (imp, statement) => {
+    if (!imp.n || !reactPackages.has(imp.n))
+      return null;
+    const trimmed = statement.trimStart();
+    if (!trimmed.startsWith("export"))
+      return null;
+    const specStart = imp.s - imp.ss;
+    const specEnd = imp.e - imp.ss;
+    const before = statement.slice(0, specStart);
+    const after = statement.slice(specEnd);
+    return `${before}${vendorUrl}${after}`;
+  });
+  const baseSource = result;
+  const imports = await parseImports(baseSource);
+  for (let i = imports.length - 1; i >= 0; i--) {
+    const imp = imports[i];
+    if (!imp)
+      continue;
+    if (!imp.n || !reactPackages.has(imp.n))
+      continue;
+    const exportName = sanitizeVendorExportName(imp.n);
+    if (imp.d > -1) {
+      const afterSpecifier = baseSource.substring(imp.e);
+      const match = afterSpecifier.match(/^['"]\s*\)/);
+      if (!match)
+        continue;
+      const endOfCall = imp.e + match[0].length;
+      const before = result.substring(0, imp.d);
+      const after = result.substring(endOfCall);
+      const replacement = `import('${vendorUrl}').then(m => m.${exportName})`;
+      result = before + replacement + after;
+    } else {
+      const beforeSpecifier = baseSource.substring(imp.ss, imp.s);
+      const fromIndex = beforeSpecifier.lastIndexOf("from");
+      if (fromIndex === -1) {
+        const before2 = result.substring(0, imp.ss);
+        const after2 = result.substring(imp.se);
+        result = before2 + `import '${vendorUrl}'` + after2;
+        continue;
+      }
+      const clause = beforeSpecifier.substring(6, fromIndex).trim();
+      let replacement = "";
+      if (clause.startsWith("*")) {
+        replacement = `import ${clause} from '${vendorUrl}'`;
+      } else if (clause.startsWith("{")) {
+        replacement = `import { ${exportName} } from '${vendorUrl}'; const ${clause} = ${exportName}`;
+      } else {
+        replacement = `import { ${exportName} as ${clause} } from '${vendorUrl}'`;
+      }
+      const before = result.substring(0, imp.ss);
+      const after = result.substring(imp.se);
+      result = before + replacement + after;
+    }
+  }
+  return result;
+}
+function sanitizeVendorExportName(pkg) {
+  return pkg.replace(/^@/, "").replace(/[\/\-]/g, "_").replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/^_/, "");
+}
+
+// src/build/transforms/mdx/compiler/mdx-compiler.ts
+init_deno_env();
+init_utils();
+
+// src/build/transforms/plugins/plugin-loader.ts
+init_deno_env();
+init_config();
+init_utils();
+
+// src/build/transforms/plugins/rehype-utils.ts
+init_deno_env();
+import { visit } from "unist-util-visit";
+function rehypePreserveNodeIds() {
+  return (tree) => {
+    visit(tree, "element", (node) => {
+      if (!node.properties) {
+        node.properties = {};
+      }
+      if (node.data && node.data.hProperties) {
+        Object.entries(
+          node.data.hProperties
+        ).forEach(([key, value]) => {
+          if (key.startsWith("data-node-")) {
+            node.properties[key] = value;
+          }
+        });
+      }
+    });
+  };
+}
+function rehypeAddClasses() {
+  return (tree) => {
+    visit(tree, "element", (node) => {
+      if (!node.properties) {
+        node.properties = {};
+      }
+      switch (node.tagName) {
+        case "p":
+          addClassName(node, "mb-4");
+          break;
+        case "h1":
+          addClassName(node, "text-4xl font-bold mb-8 mt-12");
+          break;
+        case "h2":
+          addClassName(node, "text-3xl font-bold mb-6 mt-10");
+          break;
+        case "h3":
+          addClassName(node, "text-2xl font-bold mb-4 mt-8");
+          break;
+        case "a":
+          addClassName(node, "text-blue-600 hover:text-blue-800 underline");
+          break;
+        case "code":
+          if (Array.isArray(node.properties.className) && node.properties.className.some((cls) => String(cls).includes("language-"))) {
+            addClassName(node, "block p-4 bg-gray-900 text-gray-100 rounded-lg overflow-x-auto");
+          } else {
+            addClassName(node, "px-1 py-0.5 bg-gray-100 text-gray-900 rounded text-sm");
+          }
+          break;
+        case "blockquote":
+          addClassName(node, "border-l-4 border-gray-300 pl-4 italic");
+          break;
+        case "ul":
+          addClassName(node, "list-disc list-inside mb-4");
+          break;
+        case "ol":
+          addClassName(node, "list-decimal list-inside mb-4");
+          break;
+        case "li":
+          addClassName(node, "mb-2");
+          break;
+      }
+    });
+  };
+}
+function rehypeMdxComponents() {
+  return (tree) => {
+    visit(tree, "mdxJsxFlowElement", (node) => {
+      if (!node.data) {
+        node.data = {};
+      }
+      if (!node.data.hProperties) {
+        node.data.hProperties = {};
+      }
+      node.data.hProperties["data-mdx-component"] = node.name;
+    });
+  };
+}
+function addClassName(node, className) {
+  if (!node.properties) {
+    node.properties = {};
+  }
+  if (!node.properties.className) {
+    node.properties.className = [];
+  } else if (typeof node.properties.className === "string") {
+    node.properties.className = node.properties.className.split(" ");
+  }
+  node.properties.className.push(className);
+}
+
+// src/build/transforms/plugins/remark-headings.ts
+init_deno_env();
+import GithubSlugger from "github-slugger";
+import { toString } from "mdast-util-to-string";
+import { visit as visit2 } from "unist-util-visit";
+function remarkMdxHeadings() {
+  const slugger = new GithubSlugger();
+  return (tree, file) => {
+    const headings = [];
+    slugger.reset();
+    visit2(tree, "heading", (node) => {
+      const text2 = toString(node);
+      const id = slugger.slug(text2);
+      if (!node.data) {
+        node.data = {};
+      }
+      if (!node.data.hProperties) {
+        node.data.hProperties = {};
+      }
+      node.data.hProperties.id = id;
+      headings.push({
+        text: text2,
+        id,
+        level: node.depth
+      });
+    });
+    if (!file.data) {
+      file.data = {};
+    }
+    file.data.headings = headings;
+    const headingsExport = {
+      type: "mdxjsEsm",
+      value: "",
+      data: {
+        estree: {
+          type: "Program",
+          sourceType: "module",
+          body: [
+            {
+              type: "ExportNamedDeclaration",
+              specifiers: [],
+              source: null,
+              declaration: {
+                type: "VariableDeclaration",
+                kind: "const",
+                declarations: [
+                  {
+                    type: "VariableDeclarator",
+                    id: { type: "Identifier", name: "headings" },
+                    init: {
+                      type: "ArrayExpression",
+                      elements: headings.map((h) => ({
+                        type: "ObjectExpression",
+                        properties: [
+                          {
+                            type: "Property",
+                            key: { type: "Identifier", name: "text" },
+                            value: { type: "Literal", value: h.text },
+                            kind: "init",
+                            method: false,
+                            shorthand: false,
+                            computed: false
+                          },
+                          {
+                            type: "Property",
+                            key: { type: "Identifier", name: "id" },
+                            value: { type: "Literal", value: h.id },
+                            kind: "init",
+                            method: false,
+                            shorthand: false,
+                            computed: false
+                          },
+                          {
+                            type: "Property",
+                            key: { type: "Identifier", name: "level" },
+                            value: { type: "Literal", value: h.level },
+                            kind: "init",
+                            method: false,
+                            shorthand: false,
+                            computed: false
+                          }
+                        ]
+                      }))
+                    }
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      }
+    };
+    tree.children.unshift(headingsExport);
+  };
+}
+
+// src/build/transforms/plugins/plugin-loader.ts
+init_veryfront_error();
+
+// src/build/transforms/plugins/remark-mdx-utils.ts
+init_deno_env();
+import { visit as visit3 } from "unist-util-visit";
+function remarkMdxRemoveParagraphs() {
+  return (tree) => {
+    visit3(
+      tree,
+      "paragraph",
+      (node, index, parent) => {
+        const children = Array.isArray(node?.children) ? node.children : [];
+        if (children.length === 1 && (children[0]?.type === "mdxJsxTextElement" || children[0]?.type === "mdxJsxFlowElement")) {
+          if (parent && Array.isArray(parent.children) && typeof index === "number") {
+            parent.children.splice(index, 1, children[0]);
+          }
+        }
+      }
+    );
+  };
+}
+function remarkCodeBlocks() {
+  return (tree) => {
+    visit3(tree, "code", (node) => {
+      if (!node.data) {
+        node.data = {};
+      }
+      if (!node.data.hProperties) {
+        node.data.hProperties = {};
+      }
+      if (node.lang) {
+        node.data.hProperties.className = [`language-${node.lang}`];
+      }
+      if (node.meta) {
+        const highlightMatch = node.meta.match(/\{([\d,-]+)\}/);
+        if (highlightMatch) {
+          node.data.hProperties["data-line-numbers"] = highlightMatch[1];
+        }
+      }
+    });
+  };
+}
+function remarkMdxImports() {
+  return (tree, file) => {
+    const imports = [];
+    visit3(tree, "mdxjsEsm", (node) => {
+      if (node.value?.includes("import")) {
+        const importMatches = node.value.matchAll(
+          /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g
+        );
+        for (const match of importMatches) {
+          const path = match[1];
+          if (typeof path === "string")
+            imports.push(path);
+        }
+      }
+    });
+    if (!file.data) {
+      file.data = {};
+    }
+    file.data.imports = imports;
+  };
+}
+
+// src/build/transforms/plugins/remark-node-id.ts
+init_deno_env();
+import { visit as visit4 } from "unist-util-visit";
+function remarkAddNodeId(options = {}) {
+  const { prefix = "node", includePosition = true } = options;
+  return (tree, file) => {
+    let nodeId = 0;
+    const nodeMap = /* @__PURE__ */ new Map();
+    visit4(tree, (node) => {
+      if (["yaml", "toml", "mdxjsEsm", "mdxjsFlow"].includes(String(node.type))) {
+        return;
+      }
+      if (!node.data) {
+        node.data = {};
+      }
+      if (!node.data.hProperties) {
+        node.data.hProperties = {};
+      }
+      const id = `${prefix}-${nodeId}`;
+      node.data.hProperties["data-node-id"] = id;
+      if (includePosition && node.position) {
+        const pos = node.position;
+        node.data.hProperties["data-node-start"] = pos.start.offset;
+        node.data.hProperties["data-node-end"] = pos.end.offset;
+        node.data.hProperties["data-node-line"] = pos.start.line;
+        node.data.hProperties["data-node-column"] = pos.start.column;
+        node.data.hProperties["data-node-end-line"] = pos.end.line;
+        node.data.hProperties["data-node-end-column"] = pos.end.column;
+      }
+      nodeMap.set(nodeId, {
+        id,
+        type: node.type,
+        position: node.position,
+        value: node.value
+      });
+      nodeId++;
+    });
+    if (!file.data) {
+      file.data = {};
+    }
+    file.data.nodeMap = nodeMap;
+    file.data.nodeCount = nodeId;
+  };
+}
+
+// src/build/transforms/plugins/rehype-mermaid.ts
+init_deno_env();
+import { visit as visit5 } from "unist-util-visit";
+function rehypeMermaid() {
+  return (tree) => {
+    visit5(tree, "element", (node, index, parent) => {
+      const firstChild = node.children[0];
+      if (node.tagName === "pre" && node.children.length === 1 && firstChild && firstChild.type === "element" && firstChild.tagName === "code") {
+        const codeNode = node.children[0];
+        const className = codeNode.properties?.className;
+        const isMermaid = Array.isArray(className) ? className.some(
+          (c) => String(c).includes("mermaid") || String(c).includes("language-mermaid")
+        ) : String(className || "").includes("mermaid");
+        if (isMermaid && parent && typeof index === "number") {
+          const textContent = extractText(codeNode);
+          const mermaidDiv = {
+            type: "element",
+            tagName: "div",
+            properties: {
+              className: ["mermaid"]
+            },
+            children: [{ type: "text", value: textContent }]
+          };
+          parent.children[index] = mermaidDiv;
+        }
+      }
+    });
+  };
+}
+function extractText(node) {
+  let text2 = "";
+  for (const child of node.children) {
+    if (child.type === "text") {
+      text2 += child.value;
+    } else if (child.type === "element") {
+      text2 += extractText(child);
+    }
+  }
+  return text2.trim();
+}
+
+// src/build/transforms/plugins/plugin-loader.ts
+import remarkGfm from "remark-gfm";
+import remarkFrontmatter from "remark-frontmatter";
+import rehypeHighlight from "rehype-highlight";
+import rehypeSlug from "rehype-slug";
+async function loadUserPlugins(projectDir, adapter, pluginType) {
+  try {
+    const _config = await getConfig(projectDir, adapter);
+    return [];
+  } catch (error2) {
+    serverLogger.warn(
+      `Failed to load ${pluginType} plugins from config`,
+      { error: error2 instanceof Error ? error2.message : String(error2) }
+    );
+    return [];
+  }
+}
+async function getRemarkPlugins(projectDir, adapter) {
+  const defaultPlugins = [
+    remarkGfm,
+    remarkFrontmatter,
+    remarkAddNodeId,
+    remarkMdxHeadings,
+    remarkMdxRemoveParagraphs,
+    remarkCodeBlocks,
+    remarkMdxImports
+  ];
+  if (adapter) {
+    try {
+      const userPlugins = await loadUserPlugins(projectDir, adapter, "remark");
+      return [...defaultPlugins, ...userPlugins];
+    } catch (error2) {
+      serverLogger.error(
+        "Error loading user remark plugins",
+        { error: error2 instanceof Error ? error2.message : String(error2) }
+      );
+    }
+  }
+  return defaultPlugins;
+}
+async function getRehypePlugins(projectDir, adapter) {
+  const defaultPlugins = [
+    rehypeMermaid,
+    // Must run before rehypeHighlight
+    rehypeHighlight,
+    rehypeSlug,
+    rehypePreserveNodeIds,
+    rehypeAddClasses,
+    rehypeMdxComponents
+  ];
+  if (adapter) {
+    try {
+      const userPlugins = await loadUserPlugins(projectDir, adapter, "rehype");
+      return [...defaultPlugins, ...userPlugins];
+    } catch (error2) {
+      serverLogger.error(
+        "Error loading user rehype plugins",
+        { error: error2 instanceof Error ? error2.message : String(error2) }
+      );
+    }
+  }
+  return defaultPlugins;
+}
+
+// src/build/transforms/mdx/compiler/frontmatter-extractor.ts
+init_deno_env();
+init_utils();
+async function extractYamlFrontmatter(content) {
+  if (!content.trim().startsWith("---")) {
+    return { body: content, frontmatter: {} };
+  }
+  const { extract } = await import("gray-matter");
+  const extracted = extract(content);
+  return {
+    body: extracted.body,
+    frontmatter: extracted.attrs
+  };
+}
+function extractExportConstants(body) {
+  const exportRegex = /^export\s+const\s+(\w+)\s*=\s*(['"`][^'"`\n]*['"`]|\d+(?:\.\d+)?|true|false|null)\s*;?\s*$/gm;
+  const exports = {};
+  const linesToRemove = [];
+  let match;
+  while ((match = exportRegex.exec(body)) !== null) {
+    const key = match[1];
+    const rawValue = match[2];
+    if (key && key.length > 0 && rawValue) {
+      linesToRemove.push(match[0]);
+      if (rawValue === "true") {
+        exports[key] = true;
+      } else if (rawValue === "false") {
+        exports[key] = false;
+      } else if (rawValue === "null") {
+        exports[key] = null;
+      } else if (/^\d+(?:\.\d+)?$/.test(rawValue)) {
+        exports[key] = parseFloat(rawValue);
+      } else {
+        exports[key] = rawValue.replace(/^['"`]|['"`]$/g, "");
+      }
+    }
+  }
+  let cleanedBody = body;
+  for (const line of linesToRemove) {
+    cleanedBody = cleanedBody.replace(line, "");
+  }
+  return { body: cleanedBody, exports };
+}
+async function extractFrontmatter(content, providedFrontmatter) {
+  let body = content;
+  let frontmatter = {};
+  if (content.trim().startsWith("---")) {
+    const yamlResult = await extractYamlFrontmatter(content);
+    body = yamlResult.body;
+    frontmatter = yamlResult.frontmatter;
+  }
+  if (providedFrontmatter) {
+    frontmatter = { ...frontmatter, ...providedFrontmatter };
+  }
+  const exportResult = extractExportConstants(body);
+  body = exportResult.body;
+  frontmatter = { ...frontmatter, ...exportResult.exports };
+  rendererLogger.info("Extracted frontmatter:", frontmatter);
+  return { body, frontmatter };
+}
+
+// src/build/transforms/mdx/compiler/import-rewriter.ts
+init_deno_env();
+import { dirname as dirname3, join as join4, resolve as pathResolve } from "node:path";
+function toAbsPath(spec, basedir) {
+  try {
+    if (spec.startsWith("file://"))
+      return new URL(spec).pathname;
+    if (spec.startsWith("/"))
+      return pathResolve(spec);
+    if (spec.startsWith("http://") || spec.startsWith("https://"))
+      return spec;
+    if (!spec.startsWith(".") && !spec.startsWith("/")) {
+      return spec;
+    }
+    return pathResolve(join4(basedir, spec));
+  } catch {
+    return spec;
+  }
+}
+function toBrowserFs(abs, baseUrl) {
+  if (abs.startsWith("http://") || abs.startsWith("https://"))
+    return abs;
+  const b64 = btoa(abs).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+  const path = `/_veryfront/fs/${b64}.js`;
+  return baseUrl ? `${baseUrl}${path}` : path;
+}
+function mapSpec(spec, basedir, target, baseUrl, _projectDir) {
+  if (spec.startsWith("@/")) {
+    const relativePath = spec.slice(2);
+    if (target === "browser") {
+      const path = `/_vf_modules/${relativePath}.js`;
+      return baseUrl ? `${baseUrl}${path}` : path;
+    } else {
+      return spec;
+    }
+  }
+  const abs = toAbsPath(spec, basedir);
+  if (typeof abs !== "string")
+    return spec;
+  if (abs === spec && !spec.startsWith(".") && !spec.startsWith("/") && !spec.startsWith("file://") && !spec.startsWith("http")) {
+    return spec;
+  }
+  if (target === "browser")
+    return toBrowserFs(abs, baseUrl);
+  return abs.startsWith("http") ? abs : `file://${abs}`;
+}
+function rewriteLine(line, basedir, target, baseUrl, projectDir) {
+  const mapper = (spec) => mapSpec(spec, basedir, target, baseUrl, projectDir);
+  line = line.replace(
+    /^(\s*import\s+[^'";]+?from\s+)(["'])([^"']+)(\2)/,
+    (_m, p1, q, s, q2) => `${p1}${q}${mapper(s)}${q2}`
+  );
+  line = line.replace(
+    /^(\s*import\s+)(["'])([^"']+)(\2)/,
+    (_m, p1, q, s, q2) => `${p1}${q}${mapper(s)}${q2}`
+  );
+  line = line.replace(
+    /^(\s*export\s+[^'";]+?from\s+)(["'])([^"']+)(\2)/,
+    (_m, p1, q, s, q2) => `${p1}${q}${mapper(s)}${q2}`
+  );
+  return line;
+}
+function rewriteBodyImports(body, config) {
+  const basedir = dirname3(config.filePath);
+  return body.split(/\r?\n/).map((ln) => {
+    const trimmed = ln.trimStart();
+    if (trimmed.startsWith("import") || trimmed.startsWith("export")) {
+      return rewriteLine(ln, basedir, config.target, config.baseUrl, config.projectDir);
+    }
+    return ln;
+  }).join("\n");
+}
+function rewriteCompiledImports(compiledCode, config) {
+  const basedir = dirname3(config.filePath);
+  const mapper = (spec) => mapSpec(spec, basedir, config.target, config.baseUrl, config.projectDir);
+  let code = compiledCode;
+  code = code.replace(
+    /(from\s+["'])(@\/[^"']+)(["'])/g,
+    (_m, p1, p2, p3) => `${p1}${mapper(p2)}${p3}`
+  );
+  code = code.replace(
+    /(import\(\s*["'])(@\/[^"']+)(["']\s*\))/g,
+    (_m, p1, p2, p3) => `${p1}${mapper(p2)}${p3}`
+  );
+  code = code.replace(
+    /(from\s+["'])(\.{1,2}\/[^"']+)(["'])/g,
+    (_m, p1, p2, p3) => `${p1}${mapper(p2)}${p3}`
+  );
+  code = code.replace(
+    /(from\s+["'])(file:\/\/[^"']+)(["'])/g,
+    (_m, p1, p2, p3) => `${p1}${mapper(p2)}${p3}`
+  );
+  code = code.replace(
+    /(import\(\s*["'])(\.{1,2}\/[^"']+)(["']\s*\))/g,
+    (_m, p1, p2, p3) => `${p1}${mapper(p2)}${p3}`
+  );
+  code = code.replace(
+    /(import\(\s*["'])(file:\/\/[^"']+)(["']\s*\))/g,
+    (_m, p1, p2, p3) => `${p1}${mapper(p2)}${p3}`
+  );
+  code = code.replace(/file:\/\/[A-Za-z0-9_\-./%]+/g, (match) => mapper(match));
+  return code;
+}
+
+// src/build/transforms/mdx/compiler/mdx-compiler.ts
+init_veryfront_error();
+
+// src/build/transforms/plugins/rehype-node-positions.ts
+init_deno_env();
+import { visit as visit6 } from "unist-util-visit";
+function rehypeNodePositions(options = {}) {
+  console.log("[rehypeNodePositions] Plugin called with options:", options);
+  return (tree) => {
+    console.log(
+      "[rehypeNodePositions] Processing tree, root type:",
+      tree.type,
+      "children:",
+      tree.children?.length
+    );
+    tree.children?.slice(0, 5).forEach((child, i) => {
+      console.log(
+        `[rehypeNodePositions] Child ${i}: type=${child.type}, name=${child.name || child.tagName || "N/A"}`
+      );
+    });
+    let elementCount = 0;
+    let positionCount = 0;
+    visit6(tree, (node) => {
+      if (node.type === "element") {
+        elementCount++;
+        if (node.position) {
+          positionCount++;
+          addPositionAttributes(node, node.properties || (node.properties = {}), options.filePath);
+        }
+        return;
+      }
+      if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") {
+        elementCount++;
+        console.log(
+          "[rehypeNodePositions] Found MDX JSX element:",
+          node.name,
+          "position:",
+          node.position ? "yes" : "no"
+        );
+        if (node.position) {
+          positionCount++;
+          if (!node.attributes) {
+            node.attributes = [];
+          }
+          const { start, end } = node.position;
+          if (start) {
+            node.attributes.push(
+              { type: "mdxJsxAttribute", name: "data-node-line", value: String(start.line) },
+              {
+                type: "mdxJsxAttribute",
+                name: "data-node-column",
+                value: String(start.column - 1)
+              }
+            );
+          }
+          if (end) {
+            node.attributes.push(
+              { type: "mdxJsxAttribute", name: "data-node-end-line", value: String(end.line) },
+              {
+                type: "mdxJsxAttribute",
+                name: "data-node-end-column",
+                value: String(end.column - 1)
+              }
+            );
+          }
+          if (options.filePath) {
+            node.attributes.push(
+              { type: "mdxJsxAttribute", name: "data-node-file", value: options.filePath }
+            );
+          }
+        }
+      }
+    });
+    console.log("[rehypeNodePositions] Processed", { elementCount, positionCount });
+  };
+}
+function addPositionAttributes(node, properties, filePath) {
+  if (!node.position)
+    return;
+  const { start, end } = node.position;
+  if (start) {
+    properties["data-node-line"] = start.line;
+    properties["data-node-column"] = start.column - 1;
   }
-  if (importMap.imports?.[specifier]) {
-    return importMap.imports[specifier];
+  if (end) {
+    properties["data-node-end-line"] = end.line;
+    properties["data-node-end-column"] = end.column - 1;
   }
-  if (specifier.endsWith(".js") || specifier.endsWith(".mjs") || specifier.endsWith(".cjs")) {
-    const base = specifier.replace(/\.(m|c)?js$/, "");
-    if (importMap.imports?.[base]) {
-      return importMap.imports[base];
-    }
+  if (filePath) {
+    properties["data-node-file"] = filePath;
   }
-  if (importMap.imports) {
-    for (const [key, value] of Object.entries(importMap.imports)) {
-      if (key.endsWith("/") && specifier.startsWith(key)) {
-        return value + specifier.slice(key.length);
-      }
+}
+
+// src/build/transforms/mdx/compiler/mdx-compiler.ts
+async function compileMDXRuntime(mode, projectDir, content, frontmatter, filePath, target = "server", baseUrl) {
+  try {
+    const { compile } = await import("@mdx-js/mdx");
+    const remarkPlugins = await getRemarkPlugins(projectDir);
+    const rehypePlugins = await getRehypePlugins(projectDir);
+    const extracted = await extractFrontmatter(content, frontmatter);
+    let { body } = extracted;
+    const { frontmatter: extractedFrontmatter } = extracted;
+    if (filePath && (target === "browser" || target === "server")) {
+      body = rewriteBodyImports(body, { filePath, target, baseUrl, projectDir });
+    }
+    const allRehypePlugins = [
+      ...rehypePlugins,
+      [rehypeNodePositions, { filePath }]
+    ];
+    const compiled = await compile(body, {
+      outputFormat: "program",
+      development: mode === "development",
+      remarkPlugins,
+      rehypePlugins: allRehypePlugins,
+      providerImportSource: void 0,
+      jsxImportSource: "react"
+    });
+    rendererLogger.info("MDX compiled output preview:", String(compiled).substring(0, 200));
+    rendererLogger.info("Extracted frontmatter:", extractedFrontmatter);
+    let compiledCode = String(compiled);
+    if (filePath && (target === "browser" || target === "server")) {
+      compiledCode = rewriteCompiledImports(compiledCode, {
+        filePath,
+        target,
+        baseUrl,
+        projectDir
+      });
     }
+    return {
+      compiledCode,
+      frontmatter: extractedFrontmatter,
+      globals: {},
+      headings: [],
+      nodeMap: /* @__PURE__ */ new Map()
+    };
+  } catch (error2) {
+    rendererLogger.error("[MDX Compiler] Compilation failed:", {
+      filePath,
+      error: error2 instanceof Error ? error2.message : String(error2),
+      stack: error2 instanceof Error ? error2.stack : void 0
+    });
+    throw toError(createError({
+      type: "build",
+      message: `MDX compilation error: ${error2 instanceof Error ? error2.message : String(error2)} | file: ${filePath || "<memory>"}`
+    }));
   }
-  return specifier;
 }
 
-// src/module-system/import-map/transformer.ts
-init_deno_env();
-function transformImportsWithMap(code, importMap, scope, options) {
-  let transformedCode = code;
-  transformedCode = transformedCode.replace(
-    /((?:import|export)\s+(?:[\w,{}\s*]+\s+from\s+)?|export\s+(?:\*|\{[^}]+\})\s+from\s+)["']([^"']+)["']/g,
-    (_match, prefix, specifier) => {
-      const isBare = !specifier.startsWith("http") && !specifier.startsWith("/") && !specifier.startsWith(".");
-      if (isBare && !options?.resolveBare) {
-        return `${prefix}"${specifier}"`;
-      }
-      const resolved = resolveImport(specifier, importMap, scope);
-      return `${prefix}"${resolved}"`;
-    }
-  );
-  transformedCode = transformedCode.replace(
-    /from\s+["']([^"']+)["']/g,
-    (match, specifier) => {
-      const isBare = !specifier.startsWith("http") && !specifier.startsWith("/") && !specifier.startsWith(".");
-      if (isBare && !options?.resolveBare) {
-        return match;
-      }
-      const resolved = resolveImport(specifier, importMap, scope);
-      return `from "${resolved}"`;
-    }
-  );
-  transformedCode = transformedCode.replace(
-    /import\s*\(\s*["']([^"']+)["']\s*\)/g,
-    (_match, specifier) => {
-      const resolved = resolveImport(specifier, importMap, scope);
-      return `import("${resolved}")`;
+// src/build/transforms/esm/transform-core.ts
+init_utils();
+async function transformToESM(source, filePath, projectDir, _adapter, options) {
+  const transformStart = performance.now();
+  const timings2 = {};
+  const {
+    dev = true,
+    projectId,
+    jsxImportSource = "react",
+    moduleServerUrl,
+    vendorBundleHash,
+    ssr = false
+  } = options;
+  const hashStart = performance.now();
+  const contentHash = await computeContentHash2(source);
+  timings2.hash = performance.now() - hashStart;
+  const cacheKey = generateCacheKey(projectId, filePath, contentHash, ssr);
+  const cached = getCachedTransform(cacheKey);
+  if (cached) {
+    return cached.code;
+  }
+  let transformSource = source;
+  if (filePath.endsWith(".mdx")) {
+    const mdxStart = performance.now();
+    const mdxTarget = ssr ? "server" : "browser";
+    const mdxBaseUrl = ssr ? void 0 : moduleServerUrl;
+    const mdxResult = await compileMDXRuntime(
+      dev ? "development" : "production",
+      projectDir,
+      source,
+      void 0,
+      filePath,
+      mdxTarget,
+      mdxBaseUrl
+    );
+    transformSource = mdxResult.compiledCode;
+    timings2.mdx = performance.now() - mdxStart;
+  }
+  const esbuildStart = performance.now();
+  const loader = getLoaderFromPath(filePath);
+  let result;
+  try {
+    result = await esbuild.transform(transformSource, {
+      loader,
+      format: "esm",
+      target: "es2020",
+      jsx: "automatic",
+      jsxImportSource,
+      minify: !dev,
+      sourcemap: dev ? "inline" : false,
+      treeShaking: !dev,
+      // Disable in dev mode to preserve import errors
+      keepNames: true
+    });
+  } catch (transformError) {
+    const sourcePreview = transformSource.split("\n").slice(0, 10).map(
+      (line, i) => `${String(i + 1).padStart(3, " ")}| ${line}`
+    ).join("\n");
+    rendererLogger.error("[ESM-TRANSFORM] Transform failed", {
+      filePath,
+      loader,
+      sourceLength: transformSource.length,
+      isMdx: filePath.endsWith(".mdx"),
+      error: transformError instanceof Error ? transformError.message : String(transformError)
+    });
+    rendererLogger.error("[ESM-TRANSFORM] Source preview (first 10 lines):\n" + sourcePreview);
+    const errorMsg = transformError instanceof Error ? transformError.message : String(transformError);
+    throw new Error(`ESM transform failed for ${filePath} (loader: ${loader}): ${errorMsg}`);
+  }
+  timings2.esbuild = performance.now() - esbuildStart;
+  const rewriteStart = performance.now();
+  let code = result.code;
+  code = await resolveReactImports(code, ssr);
+  code = await addDepsToEsmShUrls(code, ssr);
+  code = await resolvePathAliases(code, filePath, projectDir, ssr);
+  const apiBaseUrl = options.apiBaseUrl || Deno.env.get("VERYFRONT_API_BASE_URL") || Deno.env.get("VERYFRONT_API_URL")?.replace("/graphql", "/api") || "http://api.lvh.me:4000/api";
+  code = await resolveCrossProjectImports(code, {
+    apiBaseUrl,
+    ssr
+  });
+  if (ssr) {
+    const urlBlockResult = await blockExternalUrlImports(code, filePath);
+    code = urlBlockResult.code;
+    if (urlBlockResult.blockedUrls.length > 0) {
+      rendererLogger.warn("[ESM-TRANSFORM] Blocked external URL imports in SSR mode", {
+        file: filePath.slice(-60),
+        blockedUrls: urlBlockResult.blockedUrls
+      });
     }
-  );
-  return transformedCode;
+    code = await resolveRelativeImportsForSSR(code);
+    code = await resolveVeryfrontImports(code);
+  } else {
+    code = await resolveRelativeImports(code, filePath, projectDir, moduleServerUrl);
+    if (moduleServerUrl && vendorBundleHash) {
+      code = await rewriteVendorImports(code, moduleServerUrl, vendorBundleHash);
+    } else {
+      code = await rewriteBareImports(code, moduleServerUrl);
+    }
+  }
+  timings2.rewrite = performance.now() - rewriteStart;
+  setCachedTransform(cacheKey, code, contentHash);
+  const totalMs = performance.now() - transformStart;
+  rendererLogger.debug("[ESM-TRANSFORM] Timing breakdown", {
+    file: filePath.slice(-40),
+    totalMs: totalMs.toFixed(1),
+    hashMs: timings2.hash?.toFixed(1),
+    mdxMs: timings2.mdx?.toFixed(1),
+    esbuildMs: timings2.esbuild?.toFixed(1),
+    rewriteMs: timings2.rewrite?.toFixed(1)
+  });
+  return code;
 }
 
-// src/module-system/import-map/merger.ts
-init_deno_env();
-
 // src/build/transforms/mdx/esm-module-loader.ts
-init_runtime();
-init_process();
-import { join as join4 } from "node:path";
-var IS_TRUE_NODE = isNode && !isDeno;
+var IS_TRUE_NODE2 = isNode && !isDeno;
 var LOG_PREFIX_MDX_LOADER = "[mdx-loader]";
 var LOG_PREFIX_MDX_RENDERER = "[mdx-renderer]";
 var JSX_IMPORT_PATTERN = /import\s+([^'"]+)\s+from\s+['"]file:\/\/([^'"]+\.(jsx|tsx))['"];?/g;
@@ -9224,8 +11832,42 @@ var ESBUILD_JSX_FACTORY = "React.createElement";
 var ESBUILD_JSX_FRAGMENT = "React.Fragment";
 var HTTP_MODULE_FETCH_TIMEOUT_MS2 = 3e4;
 var _resolvedPaths = {};
+var _modulePathCache = null;
+var _modulePathCacheLoaded = false;
+async function getModulePathCache(cacheDir) {
+  if (_modulePathCache && _modulePathCacheLoaded) {
+    return _modulePathCache;
+  }
+  _modulePathCache = /* @__PURE__ */ new Map();
+  const indexPath = join6(cacheDir, "_index.json");
+  try {
+    const content = await Deno.readTextFile(indexPath);
+    const index = JSON.parse(content);
+    for (const [path, cachePath] of Object.entries(index)) {
+      _modulePathCache.set(path, cachePath);
+    }
+    rendererLogger.debug(`${LOG_PREFIX_MDX_LOADER} Loaded module index: ${_modulePathCache.size} entries`);
+  } catch {
+  }
+  _modulePathCacheLoaded = true;
+  return _modulePathCache;
+}
+async function saveModulePathCache(cacheDir) {
+  if (!_modulePathCache)
+    return;
+  const indexPath = join6(cacheDir, "_index.json");
+  const index = {};
+  for (const [path, cachePath] of _modulePathCache.entries()) {
+    index[path] = cachePath;
+  }
+  try {
+    await Deno.writeTextFile(indexPath, JSON.stringify(index));
+  } catch (error2) {
+    rendererLogger.warn(`${LOG_PREFIX_MDX_LOADER} Failed to save module index`, error2);
+  }
+}
 async function resolveNodePackage(packageSpec) {
-  if (!IS_TRUE_NODE)
+  if (!IS_TRUE_NODE2)
     return null;
   if (packageSpec in _resolvedPaths)
     return _resolvedPaths[packageSpec];
@@ -9241,7 +11883,7 @@ async function resolveNodePackage(packageSpec) {
   }
 }
 async function transformReactImportsToAbsolute(code) {
-  if (!IS_TRUE_NODE)
+  if (!IS_TRUE_NODE2)
     return code;
   const reactPath = await resolveNodePackage("react");
   const reactJsxPath = await resolveNodePackage("react/jsx-runtime");
@@ -9274,6 +11916,94 @@ async function transformReactImportsToAbsolute(code) {
   }
   return result;
 }
+function addExternalToEsmShUrls(code) {
+  if (IS_TRUE_NODE2)
+    return code;
+  return code.replace(
+    /from\s+["'](https:\/\/esm\.sh\/[^"']+)["']/g,
+    (match, url) => {
+      if (url.includes("external=")) {
+        return match;
+      }
+      if (url.includes("/react@") || url.includes("/react-dom@")) {
+        return match;
+      }
+      const separator = url.includes("?") ? "&" : "?";
+      return `from "${url}${separator}external=react,react-dom"`;
+    }
+  );
+}
+function normalizeReactToNpm(code) {
+  if (IS_TRUE_NODE2)
+    return code;
+  const REACT_VERSION = "18.3.1";
+  let result = code;
+  result = result.replace(
+    /import\s*\{([^}]*)\bjsxDEV\s+as\s+(\w+)([^}]*)\}\s*from\s*["']([^"']*\/?)jsx-dev-runtime["']/g,
+    (_match, before, alias, after, prefix) => {
+      return `import {${before}jsx as ${alias}${after}} from "${prefix}jsx-runtime"`;
+    }
+  );
+  result = result.replace(
+    /import\s*\{([^}]*)\bjsxDEV\b([^}]*)\}\s*from\s*["']([^"']*\/?)jsx-dev-runtime["']/g,
+    (_match, before, after, prefix) => {
+      return `import {${before}jsx${after}} from "${prefix}jsx-runtime"`;
+    }
+  );
+  result = result.replace(
+    /from\s+['"]https:\/\/esm\.sh\/react@[^'"\/]+\/jsx-dev-runtime[^'"]*['"]/g,
+    `from "npm:react@${REACT_VERSION}/jsx-runtime"`
+  );
+  result = result.replace(
+    /from\s+['"]https:\/\/esm\.sh\/react@[^'"\/]+\/jsx-runtime[^'"]*['"]/g,
+    `from "npm:react@${REACT_VERSION}/jsx-runtime"`
+  );
+  result = result.replace(
+    /from\s+['"]https:\/\/esm\.sh\/react-dom@[^'"\/]+\/server[^'"]*['"]/g,
+    `from "npm:react-dom@${REACT_VERSION}/server"`
+  );
+  result = result.replace(
+    /from\s+['"]npm:react\/jsx-dev-runtime['"]/g,
+    `from "npm:react@${REACT_VERSION}/jsx-runtime"`
+  );
+  result = result.replace(
+    /from\s+['"]npm:react\/jsx-runtime['"]/g,
+    `from "npm:react@${REACT_VERSION}/jsx-runtime"`
+  );
+  result = result.replace(
+    /from\s+['"]npm:react-dom\/server['"]/g,
+    `from "npm:react-dom@${REACT_VERSION}/server"`
+  );
+  result = result.replace(
+    /from\s+['"]react\/jsx-dev-runtime['"]/g,
+    `from "npm:react@${REACT_VERSION}/jsx-runtime"`
+  );
+  result = result.replace(
+    /from\s+['"]react\/jsx-runtime['"]/g,
+    `from "npm:react@${REACT_VERSION}/jsx-runtime"`
+  );
+  result = result.replace(
+    /from\s+['"]https:\/\/esm\.sh\/react@[^'"\/]+['"]/g,
+    `from "npm:react@${REACT_VERSION}"`
+  );
+  result = result.replace(
+    /from\s+['"]https:\/\/esm\.sh\/react-dom@[^'"\/]+['"]/g,
+    `from "npm:react-dom@${REACT_VERSION}"`
+  );
+  result = result.replace(
+    /from\s+['"]npm:react['"]/g,
+    `from "npm:react@${REACT_VERSION}"`
+  );
+  result = result.replace(
+    /from\s+['"]npm:react-dom['"]/g,
+    `from "npm:react-dom@${REACT_VERSION}"`
+  );
+  result = result.replace(
+    /from\s+['"]npm:@tanstack\/react-query(?:@[^'"\/]+)?['"]/g,
+    `from "https://esm.sh/@tanstack/react-query?external=react,react-dom"`
+  );
+  return result;
+}
 function hashString(input) {
   const HASH_SEED_FNV1A2 = 2166136261;
   let hash = HASH_SEED_FNV1A2 >>> 0;
@@ -9344,37 +12074,436 @@ function createHTTPPluginForMDX() {
   };
 }
 async function loadModuleESM(compiledProgramCode, context) {
+  const loadStart = performance.now();
   try {
     const { getAdapter: getAdapter2 } = await Promise.resolve().then(() => (init_detect(), detect_exports));
     const adapter = await getAdapter2();
     if (!context.esmCacheDir) {
-      if (IS_TRUE_NODE) {
-        const projectCacheDir = join4(
-          cwd(),
-          "node_modules",
-          ".cache",
-          "veryfront-mdx"
-        );
-        await adapter.fs.mkdir(projectCacheDir, { recursive: true });
-        context.esmCacheDir = projectCacheDir;
-      } else {
-        context.esmCacheDir = await adapter.fs.makeTempDir("veryfront-mdx-esm-");
+      const persistentCacheDir = join6(cwd(), ".cache", "veryfront-mdx-esm");
+      try {
+        await Deno.mkdir(persistentCacheDir, { recursive: true });
+        context.esmCacheDir = persistentCacheDir;
+        rendererLogger.info(`${LOG_PREFIX_MDX_LOADER} Using persistent cache dir: ${persistentCacheDir}`);
+      } catch {
+        if (IS_TRUE_NODE2) {
+          const projectCacheDir = join6(cwd(), "node_modules", ".cache", "veryfront-mdx");
+          await adapter.fs.mkdir(projectCacheDir, { recursive: true });
+          context.esmCacheDir = projectCacheDir;
+        } else {
+          context.esmCacheDir = await adapter.fs.makeTempDir("veryfront-mdx-esm-");
+        }
       }
     }
-    let rewritten;
-    if (IS_TRUE_NODE) {
-      rewritten = await transformReactImportsToAbsolute(compiledProgramCode);
+    let rewritten = compiledProgramCode.replace(
+      /from\s+["']@\/([^"']+)["']/g,
+      (_match, path) => {
+        const jsPath = path.endsWith(".js") ? path : `${path}.js`;
+        return `from "/_vf_modules/${jsPath}"`;
+      }
+    );
+    if (IS_TRUE_NODE2) {
+      rewritten = await transformReactImportsToAbsolute(rewritten);
     } else {
       rewritten = transformImportsWithMap(
-        compiledProgramCode,
+        rewritten,
         getDefaultImportMap(),
         void 0,
         { resolveBare: true }
       );
     }
+    const vfModulePattern = /from\s+["'](\/?)(_vf_modules\/[^"']+)["']/g;
+    const vfModuleImports = [];
+    let vfMatch;
+    while ((vfMatch = vfModulePattern.exec(rewritten)) !== null) {
+      const [original, , path] = vfMatch;
+      if (path) {
+        vfModuleImports.push({ original, path });
+      }
+    }
+    const projectDir = cwd();
+    const projectId = "default";
+    const inFlight = /* @__PURE__ */ new Map();
+    async function fetchAndCacheModule(modulePath, parentModulePath) {
+      let normalizedPath = modulePath.replace(/^\//, "");
+      if (parentModulePath && (modulePath.startsWith("./") || modulePath.startsWith("../"))) {
+        const parentDir = parentModulePath.replace(/\/[^/]+$/, "");
+        const joinedPath = posix.join(parentDir, modulePath);
+        normalizedPath = posix.normalize(joinedPath);
+        if (!normalizedPath.startsWith("_vf_modules/")) {
+          normalizedPath = `_vf_modules/${normalizedPath}`;
+        }
+      }
+      const existingFetch = inFlight.get(normalizedPath);
+      if (existingFetch) {
+        rendererLogger.debug(`${LOG_PREFIX_MDX_LOADER} Waiting for in-flight fetch: ${normalizedPath}`);
+        return existingFetch;
+      }
+      let resolveDeferred;
+      const fetchPromise = new Promise((resolve2) => {
+        resolveDeferred = resolve2;
+      });
+      inFlight.set(normalizedPath, fetchPromise);
+      const result2 = await (async () => {
+        const pathCache = await getModulePathCache(context.esmCacheDir);
+        const cachedPath = pathCache.get(normalizedPath);
+        if (cachedPath) {
+          try {
+            const stat = await adapter.fs.stat(cachedPath);
+            if (stat?.isFile) {
+              return cachedPath;
+            }
+          } catch {
+            pathCache.delete(normalizedPath);
+          }
+        }
+        try {
+          const filePathWithoutJs = normalizedPath.replace(/^_vf_modules\//, "").replace(/\.js$/, "");
+          const extensions = [".tsx", ".ts", ".jsx", ".js", ".mdx"];
+          const prefixes = ["", "src/"];
+          const prefixesToStrip = ["components/", "pages/", "lib/", "app/"];
+          let sourceCode = null;
+          let actualFilePath = null;
+          const hasKnownExt = extensions.some((ext) => filePathWithoutJs.endsWith(ext));
+          if (hasKnownExt) {
+            for (const prefix of prefixes) {
+              const tryPath = prefix + filePathWithoutJs;
+              try {
+                const content = await adapter.fs.readFile(tryPath);
+                sourceCode = typeof content === "string" ? content : new TextDecoder().decode(content);
+                actualFilePath = tryPath;
+                break;
+              } catch {
+              }
+            }
+          }
+          if (!sourceCode) {
+            const filePathWithoutExt = hasKnownExt ? filePathWithoutJs.replace(/\.(tsx|ts|jsx|js|mdx)$/, "") : filePathWithoutJs;
+            const triedPaths = [];
+            outer:
+              for (const prefix of prefixes) {
+                for (const ext of extensions) {
+                  const tryPath = prefix + filePathWithoutExt + ext;
+                  triedPaths.push(tryPath);
+                  try {
+                    const content = await adapter.fs.readFile(tryPath);
+                    sourceCode = typeof content === "string" ? content : new TextDecoder().decode(content);
+                    actualFilePath = tryPath;
+                    rendererLogger.debug(`${LOG_PREFIX_MDX_LOADER} Found file with extension`, {
+                      normalizedPath,
+                      tryPath
+                    });
+                    break outer;
+                  } catch {
+                  }
+                }
+              }
+            if (!sourceCode) {
+              rendererLogger.debug(`${LOG_PREFIX_MDX_LOADER} Extension resolution failed`, {
+                normalizedPath,
+                filePathWithoutExt,
+                triedPaths
+              });
+            }
+          }
+          if (!sourceCode) {
+            const filePathWithoutExt = hasKnownExt ? filePathWithoutJs.replace(/\.(tsx|ts|jsx|js|mdx)$/, "") : filePathWithoutJs;
+            stripLoop:
+              for (const stripPrefix of prefixesToStrip) {
+                if (filePathWithoutExt.startsWith(stripPrefix)) {
+                  const strippedPath = filePathWithoutExt.slice(stripPrefix.length);
+                  for (const ext of extensions) {
+                    const tryPath = strippedPath + ext;
+                    try {
+                      const content = await adapter.fs.readFile(tryPath);
+                      sourceCode = typeof content === "string" ? content : new TextDecoder().decode(content);
+                      actualFilePath = tryPath;
+                      rendererLogger.debug(`${LOG_PREFIX_MDX_LOADER} Found file after stripping prefix`, {
+                        originalPath: filePathWithoutJs,
+                        strippedPath: tryPath
+                      });
+                      break stripLoop;
+                    } catch {
+                    }
+                  }
+                }
+              }
+          }
+          if (!sourceCode) {
+            const basePath = hasKnownExt ? filePathWithoutJs.replace(/\.(tsx|ts|jsx|js|mdx)$/, "") : filePathWithoutJs;
+            outer:
+              for (const prefix of prefixes) {
+                for (const ext of extensions) {
+                  const tryPath = `${prefix}${basePath}/index${ext}`;
+                  try {
+                    const content = await adapter.fs.readFile(tryPath);
+                    sourceCode = typeof content === "string" ? content : new TextDecoder().decode(content);
+                    actualFilePath = tryPath;
+                    break outer;
+                  } catch {
+                  }
+                }
+              }
+          }
+          if (!sourceCode || !actualFilePath) {
+            rendererLogger.debug(
+              `${LOG_PREFIX_MDX_LOADER} Direct read failed, falling back to HTTP: ${filePathWithoutJs}`
+            );
+            const envGet = (key) => globalThis.Deno?.env?.get(key);
+            const port = envGet("VERYFRONT_DEV_PORT") || envGet("PORT") || "3001";
+            const moduleUrl = `http://localhost:${port}/${normalizedPath}?ssr=true`;
+            const response = await fetch(moduleUrl);
+            if (!response.ok) {
+              rendererLogger.warn(
+                `${LOG_PREFIX_MDX_LOADER} HTTP fetch also failed: ${moduleUrl} (${response.status})`
+              );
+              return null;
+            }
+            let moduleCode2 = await response.text();
+            moduleCode2 = addExternalToEsmShUrls(moduleCode2);
+            moduleCode2 = normalizeReactToNpm(moduleCode2);
+            const vfModuleImportPattern2 = /from\s+["'](\/?_vf_modules\/[^"'?]+)(?:\?[^"']*)?["']/g;
+            const nestedImports2 = [];
+            let match2;
+            while ((match2 = vfModuleImportPattern2.exec(moduleCode2)) !== null) {
+              if (match2[1]) {
+                nestedImports2.push({ original: match2[0], path: match2[1].replace(/^\//, "") });
+              }
+            }
+            const relativeImportPattern2 = /from\s+["'](\.\.?\/[^"'?]+)(?:\?[^"']*)?["']/g;
+            const relativeImports2 = [];
+            let relMatch2;
+            while ((relMatch2 = relativeImportPattern2.exec(moduleCode2)) !== null) {
+              if (relMatch2[1]) {
+                relativeImports2.push({ original: relMatch2[0], path: relMatch2[1] });
+              }
+            }
+            const nestedResults2 = await Promise.all(
+              nestedImports2.map(async ({ original, path: nestedPath }) => {
+                const nestedFilePath = await fetchAndCacheModule(nestedPath, normalizedPath);
+                return { original, nestedFilePath };
+              })
+            );
+            for (const { original, nestedFilePath } of nestedResults2) {
+              if (nestedFilePath) {
+                moduleCode2 = moduleCode2.replace(original, `from "file://${nestedFilePath}"`);
+              }
+            }
+            const relativeResults2 = await Promise.all(
+              relativeImports2.map(async ({ original, path: relativePath }) => {
+                const nestedFilePath = await fetchAndCacheModule(relativePath, normalizedPath);
+                return { original, nestedFilePath };
+              })
+            );
+            for (const { original, nestedFilePath } of relativeResults2) {
+              if (nestedFilePath) {
+                moduleCode2 = moduleCode2.replace(original, `from "file://${nestedFilePath}"`);
+              }
+            }
+            const unresolvedPattern3 = /from\s+["'](\/?_vf_modules\/[^"']+)["']/g;
+            const unresolvedMatches3 = [...moduleCode2.matchAll(unresolvedPattern3)];
+            if (unresolvedMatches3.length > 0) {
+              const unresolvedPaths = unresolvedMatches3.map((m) => m[1]).slice(0, 3);
+              rendererLogger.warn(
+                `${LOG_PREFIX_MDX_LOADER} Module has ${unresolvedMatches3.length} unresolved imports, skipping cache`,
+                { path: normalizedPath, unresolved: unresolvedPaths }
+              );
+              return null;
+            }
+            const contentHash2 = hashString(normalizedPath + moduleCode2);
+            const cachePath2 = join6(context.esmCacheDir, `vfmod-${contentHash2}.mjs`);
+            try {
+              const stat = await adapter.fs.stat(cachePath2);
+              if (stat?.isFile) {
+                pathCache.set(normalizedPath, cachePath2);
+                rendererLogger.debug(`${LOG_PREFIX_MDX_LOADER} Content cache hit: ${normalizedPath}`);
+                return cachePath2;
+              }
+            } catch {
+            }
+            await Deno.mkdir(context.esmCacheDir, { recursive: true });
+            await adapter.fs.writeFile(cachePath2, moduleCode2);
+            pathCache.set(normalizedPath, cachePath2);
+            await saveModulePathCache(context.esmCacheDir);
+            rendererLogger.debug(`${LOG_PREFIX_MDX_LOADER} Cached: ${normalizedPath} -> ${cachePath2}`);
+            return cachePath2;
+          }
+          let moduleCode;
+          try {
+            moduleCode = await transformToESM(
+              sourceCode,
+              actualFilePath,
+              projectDir,
+              adapter,
+              { projectId, dev: true, ssr: true }
+            );
+          } catch (transformError) {
+            rendererLogger.error(`${LOG_PREFIX_MDX_LOADER} Transform failed for module`, {
+              normalizedPath,
+              actualFilePath,
+              sourceLength: sourceCode.length,
+              sourcePreview: sourceCode.slice(0, 200),
+              error: transformError instanceof Error ? transformError.message : String(transformError)
+            });
+            throw transformError;
+          }
+          moduleCode = addExternalToEsmShUrls(moduleCode);
+          moduleCode = normalizeReactToNpm(moduleCode);
+          const vfModuleImportPattern = /from\s+["'](\/?_vf_modules\/[^"'?]+)(?:\?[^"']*)?["']/g;
+          const nestedImports = [];
+          let match;
+          while ((match = vfModuleImportPattern.exec(moduleCode)) !== null) {
+            if (match[1]) {
+              nestedImports.push({ original: match[0], path: match[1].replace(/^\//, "") });
+            }
+          }
+          const relativeImportPattern = /from\s+["'](\.\.?\/[^"'?]+)(?:\?[^"']*)?["']/g;
+          const relativeImports = [];
+          let relMatch;
+          while ((relMatch = relativeImportPattern.exec(moduleCode)) !== null) {
+            if (relMatch[1]) {
+              relativeImports.push({ original: relMatch[0], path: relMatch[1] });
+            }
+          }
+          const nestedResults = await Promise.all(
+            nestedImports.map(async ({ original, path: nestedPath }) => {
+              const nestedFilePath = await fetchAndCacheModule(nestedPath, normalizedPath);
+              return { original, nestedFilePath, nestedPath };
+            })
+          );
+          for (const { original, nestedFilePath, nestedPath } of nestedResults) {
+            if (nestedFilePath) {
+              moduleCode = moduleCode.replace(original, `from "file://${nestedFilePath}"`);
+            } else {
+              const stubCode = `
+// Stub module for missing file: ${nestedPath}
+// This file was not found in the project's published release.
+const handler = {
+  get(_, prop) {
+    if (prop === 'default' || prop === '__esModule' || typeof prop === 'symbol') {
+      return new Proxy({}, handler);
+    }
+    console.warn('[Veryfront] Missing module: ${nestedPath}. Component "' + prop + '" was not found.');
+    return () => null;
+  },
+  apply() { return null; }
+};
+export default new Proxy(function(){}, handler);
+`;
+              const stubHash = hashString(`stub:${nestedPath}`);
+              const stubPath = join6(context.esmCacheDir, `stub-${stubHash}.mjs`);
+              try {
+                await adapter.fs.writeFile(stubPath, stubCode);
+                moduleCode = moduleCode.replace(original, `from "file://${stubPath}"`);
+                rendererLogger.warn(
+                  `${LOG_PREFIX_MDX_LOADER} Created stub for missing module: ${nestedPath}`
+                );
+              } catch (e) {
+                rendererLogger.error(
+                  `${LOG_PREFIX_MDX_LOADER} Failed to create stub for: ${nestedPath}`,
+                  e
+                );
+              }
+            }
+          }
+          const relativeResults = await Promise.all(
+            relativeImports.map(async ({ original, path: relativePath }) => {
+              const nestedFilePath = await fetchAndCacheModule(relativePath, normalizedPath);
+              return { original, nestedFilePath, relativePath };
+            })
+          );
+          for (const { original, nestedFilePath, relativePath } of relativeResults) {
+            if (nestedFilePath) {
+              moduleCode = moduleCode.replace(original, `from "file://${nestedFilePath}"`);
+            } else {
+              const stubCode = `
+// Stub module for missing file: ${relativePath}
+// This file was not found in the project's published release.
+const handler = {
+  get(_, prop) {
+    if (prop === 'default' || prop === '__esModule' || typeof prop === 'symbol') {
+      return new Proxy({}, handler);
+    }
+    console.warn('[Veryfront] Missing module: ${relativePath}. Component "' + prop + '" was not found.');
+    return () => null;
+  },
+  apply() { return null; }
+};
+export default new Proxy(function(){}, handler);
+`;
+              const stubHash = hashString(`stub:${relativePath}`);
+              const stubPath = join6(context.esmCacheDir, `stub-${stubHash}.mjs`);
+              try {
+                await adapter.fs.writeFile(stubPath, stubCode);
+                moduleCode = moduleCode.replace(original, `from "file://${stubPath}"`);
+                rendererLogger.warn(
+                  `${LOG_PREFIX_MDX_LOADER} Created stub for missing module: ${relativePath}`
+                );
+              } catch (e) {
+                rendererLogger.error(
+                  `${LOG_PREFIX_MDX_LOADER} Failed to create stub for: ${relativePath}`,
+                  e
+                );
+              }
+            }
+          }
+          const unresolvedPattern2 = /from\s+["'](\/?_vf_modules\/[^"']+)["']/g;
+          const unresolvedMatches2 = [...moduleCode.matchAll(unresolvedPattern2)];
+          if (unresolvedMatches2.length > 0) {
+            const unresolvedPaths = unresolvedMatches2.map((m) => m[1]).slice(0, 3);
+            rendererLogger.warn(
+              `${LOG_PREFIX_MDX_LOADER} Module has ${unresolvedMatches2.length} unresolved imports, skipping cache`,
+              { path: normalizedPath, unresolved: unresolvedPaths }
+            );
+            return null;
+          }
+          const contentHash = hashString(normalizedPath + moduleCode);
+          const cachePath = join6(context.esmCacheDir, `vfmod-${contentHash}.mjs`);
+          try {
+            const stat = await adapter.fs.stat(cachePath);
+            if (stat?.isFile) {
+              pathCache.set(normalizedPath, cachePath);
+              rendererLogger.debug(`${LOG_PREFIX_MDX_LOADER} Content cache hit: ${normalizedPath}`);
+              return cachePath;
+            }
+          } catch {
+          }
+          await Deno.mkdir(context.esmCacheDir, { recursive: true });
+          await adapter.fs.writeFile(cachePath, moduleCode);
+          pathCache.set(normalizedPath, cachePath);
+          await saveModulePathCache(context.esmCacheDir);
+          rendererLogger.debug(
+            `${LOG_PREFIX_MDX_LOADER} Cached vf_module: ${normalizedPath} -> ${cachePath}`
+          );
+          return cachePath;
+        } catch (error2) {
+          rendererLogger.warn(`${LOG_PREFIX_MDX_LOADER} Failed to process ${normalizedPath}`, error2);
+          return null;
+        }
+      })();
+      resolveDeferred(result2);
+      inFlight.delete(normalizedPath);
+      return result2;
+    }
+    const fetchStart = performance.now();
+    const vfModuleResults = await Promise.all(
+      vfModuleImports.map(async ({ original, path }) => {
+        const filePath2 = await fetchAndCacheModule(path);
+        return { original, filePath: filePath2 };
+      })
+    );
+    const fetchEnd = performance.now();
+    rendererLogger.info(`${LOG_PREFIX_MDX_LOADER} Module fetch phase completed`, {
+      moduleCount: vfModuleImports.length,
+      durationMs: (fetchEnd - fetchStart).toFixed(1)
+    });
+    for (const { original, filePath: filePath2 } of vfModuleResults) {
+      if (filePath2) {
+        rewritten = rewritten.replace(original, `from "file://${filePath2}"`);
+      }
+    }
     let jsxMatch;
     const jsxTransforms = [];
-    const { transform } = await import("esbuild/mod.js");
+    const { transform: transform2 } = await import("esbuild/mod.js");
     while ((jsxMatch = JSX_IMPORT_PATTERN.exec(rewritten)) !== null) {
       const [fullMatch, importClause, filePath2, ext] = jsxMatch;
       if (!filePath2) {
@@ -9385,7 +12514,7 @@ async function loadModuleESM(compiledProgramCode, context) {
       }
       try {
         const jsxCode = await adapter.fs.readFile(filePath2);
-        const result2 = await transform(jsxCode, {
+        const result2 = await transform2(jsxCode, {
           loader: ext === "tsx" ? "tsx" : "jsx",
           jsx: "transform",
           jsxFactory: ESBUILD_JSX_FACTORY,
@@ -9398,7 +12527,7 @@ async function loadModuleESM(compiledProgramCode, context) {
 ${transformed}`;
         }
         const transformedFileName = `jsx-${hashString(filePath2)}.mjs`;
-        const transformedPath = join4(context.esmCacheDir, transformedFileName);
+        const transformedPath = join6(context.esmCacheDir, transformedFileName);
         await adapter.fs.writeFile(transformedPath, transformed);
         jsxTransforms.push({
           original: fullMatch,
@@ -9417,10 +12546,10 @@ ${transformed}`;
     if (/\bconst\s+MDXLayout\b/.test(rewritten) && !/export\s+\{[^}]*MDXLayout/.test(rewritten)) {
       rewritten += "\nexport { MDXLayout as __vfLayout };\n";
     }
-    if (IS_TRUE_NODE && HTTP_IMPORT_PATTERN.test(rewritten)) {
-      rendererLogger.info(`${LOG_PREFIX_MDX_LOADER} Bundling HTTP imports via esbuild for Node.js`);
+    if (HTTP_IMPORT_PATTERN.test(rewritten)) {
+      rendererLogger.info(`${LOG_PREFIX_MDX_LOADER} Bundling HTTP imports via esbuild`);
       const { build: build2 } = await import("esbuild/mod.js");
-      const tempSourcePath = join4(context.esmCacheDir, `temp-${hashString(rewritten)}.mjs`);
+      const tempSourcePath = join6(context.esmCacheDir, `temp-${hashString(rewritten)}.mjs`);
       await adapter.fs.writeFile(tempSourcePath, rewritten);
       try {
         const result2 = await build2({
@@ -9440,8 +12569,8 @@ ${transformed}`;
           rendererLogger.info(`${LOG_PREFIX_MDX_LOADER} Successfully bundled HTTP imports`);
         }
       } catch (bundleError) {
-        rendererLogger.warn(
-          `${LOG_PREFIX_MDX_LOADER} Failed to bundle HTTP imports, falling back to original code`,
+        rendererLogger.error(
+          `${LOG_PREFIX_MDX_LOADER} Failed to bundle HTTP imports`,
           bundleError
         );
       } finally {
@@ -9456,13 +12585,23 @@ ${transformed}`;
         }
       }
     }
+    rewritten = addExternalToEsmShUrls(rewritten);
+    rewritten = normalizeReactToNpm(rewritten);
     const codeHash = hashString(rewritten);
     const namespace = getCacheNamespace() || "default";
     const compositeKey = `${namespace}:${codeHash}`;
     const cached = context.moduleCache.get(compositeKey);
     if (cached)
       return cached;
-    const nsDir = join4(context.esmCacheDir, namespace);
+    const unresolvedPattern = /from\s+["'](\/?_vf_modules\/[^"']+)["']/g;
+    const unresolvedMatches = [...rewritten.matchAll(unresolvedPattern)];
+    if (unresolvedMatches.length > 0) {
+      const unresolvedPaths = unresolvedMatches.map((m) => m[1]).slice(0, 5);
+      const errorMsg = `MDX has ${unresolvedMatches.length} unresolved module imports: ${unresolvedPaths.join(", ")}`;
+      rendererLogger.error(`${LOG_PREFIX_MDX_RENDERER} ${errorMsg}`);
+      throw new Error(errorMsg);
+    }
+    const nsDir = join6(context.esmCacheDir, namespace);
     try {
       await adapter.fs.mkdir(nsDir, { recursive: true });
     } catch (e) {
@@ -9471,7 +12610,7 @@ ${transformed}`;
         e instanceof Error ? e : String(e)
       );
     }
-    const filePath = join4(nsDir, `${codeHash}.mjs`);
+    const filePath = join6(nsDir, `${codeHash}.mjs`);
     try {
       const stat = await adapter.fs.stat(filePath);
       if (!stat?.isFile) {
@@ -9499,6 +12638,10 @@ ${transformed}`;
       MainLayout: mod?.MainLayout
     };
     context.moduleCache.set(compositeKey, result);
+    const loadEnd = performance.now();
+    rendererLogger.info(`${LOG_PREFIX_MDX_LOADER} loadModuleESM completed`, {
+      durationMs: (loadEnd - loadStart).toFixed(1)
+    });
     return result;
   } catch (error2) {
     rendererLogger.error(`${LOG_PREFIX_MDX_RENDERER} MDX ESM load failed:`, error2);
@@ -9557,7 +12700,7 @@ function parseJsonish(value) {
 }
 
 // src/build/transforms/mdx/module-loader/metadata-extractor.ts
-function extractFrontmatter(moduleCode) {
+function extractFrontmatter2(moduleCode) {
   try {
     const fmIndex = moduleCode.search(/(?:export\s+)?const\s+frontmatter\s*=\s*/);
     if (fmIndex < 0)
@@ -9656,7 +12799,7 @@ function parseMDXCode(compiledCode) {
     rendererLogger.debug("Code snippet:", cleanedCode.substring(0, 200));
   }
   const exports = {};
-  const frontmatter = extractFrontmatter(cleanedCode);
+  const frontmatter = extractFrontmatter2(cleanedCode);
   if (frontmatter) {
     exports.frontmatter = frontmatter;
   }
@@ -10077,6 +13220,9 @@ init_config();
 // src/security/client/html-sanitizer.ts
 init_deno_env();
 
+// src/html/html-escape.ts
+init_deno_env();
+
 // src/routing/client/viewport-prefetch.ts
 init_deno_env();
 init_utils();
@@ -10088,7 +13234,7 @@ init_deno_env();
 init_deno_env();
 init_utils();
 init_config();
-import { join as join7 } from "node:path";
+import { join as join9 } from "node:path";
 init_veryfront_error();
 
 // src/http/responses.ts
@@ -10760,11 +13906,21 @@ function createHttpInstruments(meter, config) {
 
 // src/observability/instruments/memory-instruments.ts
 init_deno_env();
+var V8_HEAP_LIMIT_MB = (() => {
+  try {
+    const flags = Deno.env.get("DENO_V8_FLAGS") ?? "";
+    const match = flags.match(/--max-old-space-size=(\d+)/);
+    if (match?.[1])
+      return parseInt(match[1], 10);
+  } catch {
+  }
+  return 5120;
+})();
 function createMemoryInstruments(meter, config) {
   const memoryUsageGauge = meter.createObservableGauge(
     `${config.prefix}.memory.usage`,
     {
-      description: "Memory usage",
+      description: "Memory usage (RSS)",
       unit: "bytes"
     }
   );
@@ -10777,7 +13933,7 @@ function createMemoryInstruments(meter, config) {
   const heapUsageGauge = meter.createObservableGauge(
     `${config.prefix}.memory.heap`,
     {
-      description: "Heap memory usage",
+      description: "V8 heap memory used",
       unit: "bytes"
     }
   );
@@ -10787,9 +13943,39 @@ function createMemoryInstruments(meter, config) {
       result.observe(memoryUsage2.heapUsed);
     }
   });
+  const heapTotalGauge = meter.createObservableGauge(
+    `${config.prefix}.memory.heap_total`,
+    {
+      description: "V8 heap memory allocated",
+      unit: "bytes"
+    }
+  );
+  heapTotalGauge.addCallback((result) => {
+    const memoryUsage2 = getMemoryUsage();
+    if (memoryUsage2) {
+      result.observe(memoryUsage2.heapTotal);
+    }
+  });
+  const heapPercentGauge = meter.createObservableGauge(
+    `${config.prefix}.memory.heap_percent`,
+    {
+      description: "V8 heap usage as percentage of configured limit",
+      unit: "percent"
+    }
+  );
+  heapPercentGauge.addCallback((result) => {
+    const memoryUsage2 = getMemoryUsage();
+    if (memoryUsage2) {
+      const heapUsedMB = memoryUsage2.heapUsed / (1024 * 1024);
+      const percent = heapUsedMB / V8_HEAP_LIMIT_MB * 100;
+      result.observe(Math.round(percent * 100) / 100);
+    }
+  });
   return {
     memoryUsageGauge,
-    heapUsageGauge
+    heapUsageGauge,
+    heapTotalGauge,
+    heapPercentGauge
   };
 }
 
@@ -10923,7 +14109,9 @@ function initializeInstruments(meter, config, runtimeState) {
     corsRejectionCounter: null,
     securityHeadersCounter: null,
     memoryUsageGauge: null,
-    heapUsageGauge: null
+    heapUsageGauge: null,
+    heapTotalGauge: null,
+    heapPercentGauge: null
   };
   try {
     const httpInstruments = createHttpInstruments(meter, config);
@@ -11088,7 +14276,9 @@ var MetricsManager = class {
       corsRejectionCounter: null,
       securityHeadersCounter: null,
       memoryUsageGauge: null,
-      heapUsageGauge: null
+      heapUsageGauge: null,
+      heapTotalGauge: null,
+      heapPercentGauge: null
     };
   }
   async initialize(config = {}, adapter) {
@@ -11186,6 +14376,10 @@ init_deno_env();
 // src/observability/auto-instrument/wrappers.ts
 init_deno_env();
 
+// src/observability/tracing/otlp-setup.ts
+init_deno_env();
+init_utils();
+
 // src/security/http/cors/validators.ts
 async function validateOrigin(requestOrigin, config) {
   if (!config) {
@@ -11464,26 +14658,13 @@ function generateNonce() {
   crypto.getRandomValues(array);
   return btoa(String.fromCharCode(...array));
 }
-function buildCSP(isDev, nonce, cspUserHeader, config, adapter) {
+function buildCSP(_isDev, nonce, cspUserHeader, config, adapter) {
   const envCsp = adapter?.env?.get?.("VERYFRONT_CSP");
   if (envCsp?.trim())
     return envCsp.replace(/{NONCE}/g, nonce);
-  const defaultCsp = isDev ? [
-    "default-src 'self'",
-    `style-src 'self' 'unsafe-inline' https://esm.sh https://cdnjs.cloudflare.com https://cdn.veryfront.com https://cdn.jsdelivr.net https://cdn.tailwindcss.com`,
-    "img-src 'self' data: https://cdn.veryfront.com https://cdnjs.cloudflare.com",
-    `script-src 'self' 'nonce-${nonce}' 'unsafe-eval' https://esm.sh https://cdn.tailwindcss.com`,
-    "connect-src 'self' https://esm.sh ws://localhost:* wss://localhost:*",
-    "font-src 'self' data: https://cdnjs.cloudflare.com"
-  ].join("; ") : [
-    "default-src 'self'",
-    `style-src 'self' 'nonce-${nonce}'`,
-    "img-src 'self' data:",
-    `script-src 'self' 'nonce-${nonce}'`,
-    "connect-src 'self'"
-  ].join("; ");
+  const defaultCsp = "";
   if (cspUserHeader?.trim()) {
-    return `${cspUserHeader.replace(/{NONCE}/g, nonce)}; ${defaultCsp}`;
+    return cspUserHeader.replace(/{NONCE}/g, nonce);
   }
   const cfgCsp = config?.csp;
   if (cfgCsp && typeof cfgCsp === "object") {
@@ -11496,7 +14677,7 @@ function buildCSP(isDev, nonce, cspUserHeader, config, adapter) {
       pieces.push(`${key} ${val}`.replace(/{NONCE}/g, nonce));
     }
     if (pieces.length > 0) {
-      return `${pieces.join("; ")}; ${defaultCsp}`;
+      return pieces.join("; ");
     }
   }
   return defaultCsp;
@@ -11507,7 +14688,7 @@ function getSecurityHeader(headerName, defaultValue, config, adapter) {
   const envValue = adapter?.env?.get?.(`VERYFRONT_${headerName}`);
   return (typeof configValue === "string" ? configValue : void 0) || envValue || defaultValue;
 }
-function applySecurityHeaders(headers, isDev, nonce, cspUserHeader, config, adapter) {
+function applySecurityHeaders(headers, isDev, nonce, cspUserHeader, config, adapter, studioEmbed) {
   const getHeaderOverride = (name) => {
     const overrides = config?.headers;
     if (!overrides)
@@ -11522,8 +14703,10 @@ function applySecurityHeaders(headers, isDev, nonce, cspUserHeader, config, adap
   };
   const contentTypeOptions = getHeaderOverride("x-content-type-options") ?? "nosniff";
   headers.set("X-Content-Type-Options", contentTypeOptions);
-  const frameOptions = getHeaderOverride("x-frame-options") ?? "DENY";
-  headers.set("X-Frame-Options", frameOptions);
+  if (!isDev && !studioEmbed) {
+    const frameOptions = getHeaderOverride("x-frame-options") ?? "DENY";
+    headers.set("X-Frame-Options", frameOptions);
+  }
   const xssProtection = getHeaderOverride("x-xss-protection") ?? "1; mode=block";
   headers.set("X-XSS-Protection", xssProtection);
   const csp = buildCSP(isDev, nonce, cspUserHeader, config, adapter);
@@ -11630,7 +14813,8 @@ function withSecurity(config) {
     this.nonce,
     this.cspUserHeader,
     cfg,
-    this.adapter
+    this.adapter,
+    this.studioEmbed
   );
   return this;
 }
@@ -11855,6 +15039,7 @@ var ResponseBuilder = class {
     this.nonce = config?.nonce ?? generateNonce();
     this.cspUserHeader = config?.cspUserHeader ?? null;
     this.adapter = config?.adapter;
+    this.studioEmbed = config?.studioEmbed ?? false;
   }
   static {
     this.error = error;
@@ -12275,6 +15460,7 @@ init_deno_env();
 init_utils();
 init_utils();
 init_utils();
+init_utils();
 
 // src/routing/api/module-loader/http-validator.ts
 init_deno_env();
@@ -12287,13 +15473,7 @@ init_utils();
 
 // src/routing/api/module-loader/loader.ts
 init_veryfront_error();
-
-// src/platform/compat/fs.ts
-init_deno_env();
-init_veryfront_error();
-init_runtime();
-
-// src/routing/api/module-loader/loader.ts
+init_fs();
 init_runtime();
 
 // src/routing/api/route-discovery.ts
@@ -12303,13 +15483,14 @@ import { relative } from "node:path";
 // src/core/utils/file-discovery.ts
 init_deno_env();
 init_deno2();
-import { join as join6 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/routing/api/route-executor.ts
 init_deno_env();
 
 // src/routing/api/context-builder.ts
 init_deno_env();
+init_cookie_utils();
 
 // src/routing/api/route-executor.ts
 init_veryfront_error();