veryfront 0.0.73 → 0.0.75

package/dist/components.js

@@ -1,5 +1,12 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require2 = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -89,6 +96,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 error;
+  for (const arg of args) {
+    if (arg instanceof Error) {
+      error = serializeError(arg);
+    } else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+      context = { ...context, ...arg };
+    }
+  }
+  return { context, error };
+}
 function parseLogLevel(levelString) {
   if (!levelString)
     return void 0;
@@ -113,8 +161,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;
@@ -123,7 +173,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();
@@ -141,47 +194,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 } = 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 (error) {
+          entry.error = error;
         }
+        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 (error) {
-          const end = performance.now();
-          this.error(`${label} failed after ${(end - start).toFixed(2)}ms`, error);
+          const durationMs = performance.now() - start;
+          this.error(`${label} failed`, { durationMs: Math.round(durationMs) }, error);
           throw error;
         }
       }
@@ -202,6 +312,7 @@ var init_logger = __esm({
     rendererLogger = createLogger("RENDERER");
     bundlerLogger = createLogger("BUNDLER");
     agentLogger = createLogger("AGENT");
+    proxyLogger = createLogger("PROXY");
     logger = createLogger("VERYFRONT");
   }
 });
@@ -274,7 +385,7 @@ var init_deno = __esm({
   "deno.json"() {
     deno_default = {
       name: "veryfront",
-      version: "0.0.73",
+      version: "0.0.75",
       nodeModulesDir: "auto",
       exclude: [
         "npm/",
@@ -306,7 +417,11 @@ var init_deno = __esm({
         "./oauth": "./src/core/oauth/index.ts",
         "./oauth/providers": "./src/core/oauth/providers/index.ts",
         "./oauth/handlers": "./src/core/oauth/handlers/index.ts",
-        "./oauth/token-store": "./src/core/oauth/token-store/index.ts"
+        "./oauth/token-store": "./src/core/oauth/token-store/index.ts",
+        "./head": "./src/exports/head.ts",
+        "./router": "./src/exports/router.ts",
+        "./context": "./src/exports/context.ts",
+        "./fonts": "./src/exports/fonts.ts"
       },
       imports: {
         "@veryfront": "./src/index.ts",
@@ -359,12 +474,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",
+        "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",
@@ -374,27 +489,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.4",
         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",
@@ -402,7 +526,7 @@ var init_deno = __esm({
         strict: true,
         noImplicitAny: true,
         noUncheckedIndexedAccess: true,
-        types: [],
+        types: ["npm:@types/react@18"],
         lib: [
           "deno.window",
           "dom",
@@ -417,9 +541,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",
@@ -532,13 +656,14 @@ 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"() {
     init_deno_env();
     init_deno();
     init_process();
     VERSION = getEnv("VERYFRONT_VERSION") || (typeof deno_default.version === "string" ? deno_default.version : "0.0.0");
+    SERVER_START_TIME = Date.now();
   }
 });
 
@@ -577,7 +702,7 @@ 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"() {
     init_deno_env();
@@ -593,6 +718,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";
   }
 });
@@ -1312,8 +1438,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;
@@ -1452,6 +1578,376 @@ 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"() {
+    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"() {
+    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"() {
+    init_deno_env();
+  }
+});
+
 // src/core/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -1599,6 +2095,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,
@@ -1609,13 +2106,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,
@@ -1646,6 +2152,7 @@ __export(utils_exports, {
   isDebugEnabled: () => isDebugEnabled,
   isDeepInspectEnabled: () => isDeepInspectEnabled,
   isDevelopmentEnvironment: () => isDevelopmentEnvironment,
+  isEnabled: () => isEnabled,
   isInternalEndpoint: () => isInternalEndpoint,
   isProductionEnvironment: () => isProductionEnvironment,
   isRSCEnabled: () => isRSCEnabled,
@@ -1662,13 +2169,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({
@@ -1687,6 +2202,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();
   }
 });
 
@@ -1712,6 +2231,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"() {
@@ -1727,6 +2296,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(),
@@ -1822,6 +2394,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(),
@@ -1854,71 +2428,434 @@ var init_schema = __esm({
   }
 });
 
-// src/core/config/loader.ts
-import { join } from "node:path";
-function getDefaultImportMapForConfig() {
-  return { imports: getReactImportMap(REACT_DEFAULT_VERSION) };
+// src/platform/compat/fs.ts
+function createFileSystem() {
+  if (isDeno) {
+    return new DenoFileSystem();
+  } else {
+    return new NodeFileSystem();
+  }
 }
-var DEFAULT_CONFIG;
-var init_loader = __esm({
-  "src/core/config/loader.ts"() {
+var NodeFileSystem, DenoFileSystem;
+var init_fs = __esm({
+  "src/platform/compat/fs.ts"() {
     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
+    init_veryfront_error();
+    init_runtime();
+    NodeFileSystem = class {
+      fs = null;
+      os = null;
+      path = null;
+      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"
+          }));
         }
-      },
-      dev: {
-        port: DEFAULT_PORT,
-        host: "localhost",
-        open: false
-      },
-      resolve: {
-        importMap: getDefaultImportMapForConfig()
-      },
-      client: {
-        moduleResolution: "cdn",
-        cdn: {
-          provider: "esm.sh",
-          versions: "auto"
+        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 (error) {
+          if (error.code === "ENOENT") {
+            return false;
+          }
+          throw error;
         }
       }
-    };
-  }
-});
-
+      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 (error) {
+          if (error instanceof Deno.errors.NotFound) {
+            return false;
+          }
+          throw error;
+        }
+      }
+      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 cors = security?.cors;
+  if (!cors || typeof cors !== "object" || Array.isArray(cors)) {
+    return;
+  }
+  const corsObj = cors;
+  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" || adapterName === "MultiProjectFSAdapter";
+}
+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 } = await import("esbuild");
+  const result = await build({
+    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 (error) {
+    if (error instanceof ConfigValidationError) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.startsWith("Invalid veryfront.config")) {
+      throw error;
+    }
+    throw error;
+  }
+}
+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 (error) {
+      if (error instanceof ConfigValidationError) {
+        throw error;
+      }
+      if (error instanceof Error && error.message.startsWith("Invalid veryfront.config")) {
+        throw error;
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      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"() {
+    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
 var init_define_config = __esm({
   "src/core/config/define-config.ts"() {
@@ -2204,7 +3141,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");
@@ -2216,7 +3153,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,
@@ -2344,9 +3281,9 @@ var init_filesystem_adapter = __esm({
       }
       async makeTempDir(prefix) {
         const { mkdtemp } = await import("node:fs/promises");
-        const { join: join5 } = await import("node:path");
+        const { join: join7 } = await import("node:path");
         const { tmpdir } = await import("node:os");
-        return await mkdtemp(join5(tmpdir(), prefix));
+        return await mkdtemp(join7(tmpdir(), prefix));
       }
       watch(paths, options) {
         const pathArray = Array.isArray(paths) ? paths : [paths];
@@ -2848,6 +3785,14 @@ var init_error_handlers = __esm({
   }
 });
 
+// src/core/errors/error-context.ts
+var init_error_context = __esm({
+  "src/core/errors/error-context.ts"() {
+    init_deno_env();
+    init_logger();
+  }
+});
+
 // src/core/errors/error-codes.ts
 function getErrorDocsUrl(code) {
   return `https://veryfront.com/docs/errors/${code}`;
@@ -3990,6 +4935,7 @@ var init_errors = __esm({
     init_runtime_errors();
     init_system_errors();
     init_error_handlers();
+    init_error_context();
     init_catalog();
     init_user_friendly();
   }
@@ -4059,9 +5005,9 @@ var init_filesystem_adapter2 = __esm({
       }
       async makeTempDir(prefix) {
         const { mkdtemp } = await import("node:fs/promises");
-        const { join: join5 } = await import("node:path");
+        const { join: join7 } = await import("node:path");
         const { tmpdir } = await import("node:os");
-        return await mkdtemp(join5(tmpdir(), prefix));
+        return await mkdtemp(join7(tmpdir(), prefix));
       }
       watch(paths, options) {
         const pathArray = Array.isArray(paths) ? paths : [paths];
@@ -5134,6 +6080,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") {
@@ -5211,20 +6160,110 @@ 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();
+
+// src/build/transforms/esm/package-registry.ts
+init_deno_env();
+var REACT_VERSION = "18.3.1";
+var CONTEXT_PACKAGES = {
+  "@tanstack/react-query": { version: "5", external: ["react"] },
+  "@tanstack/query-core": { version: "5", external: [] },
+  "next-themes": { version: "0.4", external: ["react"] },
+  "framer-motion": { version: "11", external: ["react"] },
+  "react-hook-form": { version: "7", external: ["react", "react-dom"] }
+};
+var CONTEXT_PACKAGE_NAMES = Object.keys(CONTEXT_PACKAGES);
+function getEsmShUrl(pkg, version, external) {
+  const base = `https://esm.sh/${pkg}@${version}`;
+  const params = [`target=es2022`];
+  if (external?.length) {
+    params.push(`external=${external.join(",")}`);
+  }
+  return `${base}?${params.join("&")}`;
+}
+function getContextPackageUrlSSR(pkg) {
+  const config = CONTEXT_PACKAGES[pkg];
+  return getEsmShUrl(pkg, config.version, config.external);
+}
+function getContextPackageUrlBrowser(pkg) {
+  const config = CONTEXT_PACKAGES[pkg];
+  return getEsmShUrl(pkg, config.version, config.external);
+}
+function isContextPackage(pkg) {
+  return pkg in CONTEXT_PACKAGES;
+}
+function getReactUrls() {
+  return {
+    react: `https://esm.sh/react@${REACT_VERSION}?target=es2022`,
+    "react-dom": `https://esm.sh/react-dom@${REACT_VERSION}?target=es2022`,
+    "react-dom/client": `https://esm.sh/react-dom@${REACT_VERSION}/client?target=es2022`,
+    "react-dom/server": `https://esm.sh/react-dom@${REACT_VERSION}/server?target=es2022`,
+    "react/jsx-runtime": `https://esm.sh/react@${REACT_VERSION}/jsx-runtime?target=es2022`,
+    "react/jsx-dev-runtime": `https://esm.sh/react@${REACT_VERSION}/jsx-dev-runtime?target=es2022`
+  };
+}
+function getReactImportMap2() {
+  return {
+    ...getReactUrls(),
+    // Prefix match for any react/* subpath imports
+    "react/": `https://esm.sh/react@${REACT_VERSION}/?target=es2022`
+  };
+}
+
+// src/module-system/import-map/default-import-map.ts
+function getVeryfrontSsrImportMap() {
+  return {
+    "veryfront/head": "veryfront/head",
+    "veryfront/router": "veryfront/router",
+    "veryfront/context": "veryfront/context",
+    "veryfront/fonts": "veryfront/fonts"
+  };
+}
+function getContextPackageImportMapSSR() {
+  const map = {};
+  for (const pkg of CONTEXT_PACKAGE_NAMES) {
+    map[pkg] = getContextPackageUrlSSR(pkg);
+  }
+  return map;
+}
 function getDefaultImportMap() {
-  const reactVersion = REACT_DEFAULT_VERSION;
-  const importMap = getReactImportMap(reactVersion);
-  importMap["react/"] = `https://esm.sh/react@${reactVersion}/`;
-  return { imports: importMap };
+  return {
+    imports: {
+      // Veryfront exports - local resolution
+      ...getVeryfrontSsrImportMap(),
+      // Context packages via esm.sh URLs (matches browser)
+      ...getContextPackageImportMapSSR()
+    }
+  };
 }
 
 // src/module-system/import-map/resolver.ts
 init_deno_env();
+function extractEsmShPackage(url) {
+  if (!url.startsWith("https://esm.sh/") && !url.startsWith("http://esm.sh/")) {
+    return null;
+  }
+  try {
+    const parsed = new URL(url);
+    let pathname = parsed.pathname.slice(1);
+    pathname = pathname.replace(/^v\d+\//, "");
+    let packageName;
+    if (pathname.startsWith("@")) {
+      const parts = pathname.split("/");
+      const scopedName = parts.slice(0, 2).join("/");
+      packageName = scopedName.replace(/@[\d.]+.*$/, "");
+    } else {
+      const parts = pathname.split("@");
+      packageName = (parts[0] ?? "").split("/")[0] ?? "";
+    }
+    return packageName || null;
+  } catch {
+    return null;
+  }
+}
 function resolveImport(specifier, importMap, scope) {
   if (scope && importMap.scopes?.[scope]?.[specifier]) {
     return importMap.scopes[scope][specifier];
@@ -5232,6 +6271,35 @@ function resolveImport(specifier, importMap, scope) {
   if (importMap.imports?.[specifier]) {
     return importMap.imports[specifier];
   }
+  if (specifier.startsWith("https://esm.sh/") || specifier.startsWith("http://esm.sh/")) {
+    const esmShPackage = extractEsmShPackage(specifier);
+    const scopedMapping = scope && esmShPackage && importMap.scopes?.[scope]?.[esmShPackage];
+    const globalMapping = esmShPackage && importMap.imports?.[esmShPackage];
+    const mapping = scopedMapping || globalMapping;
+    if (mapping) {
+      const url = new URL(specifier);
+      const pathname = url.pathname.slice(1).replace(/^v\d+\//, "");
+      let subpath = "";
+      if (pathname.startsWith("@")) {
+        const parts = pathname.split("/");
+        if (parts.length > 2) {
+          const packageParts = parts.slice(0, 2).join("/");
+          const afterPackage = pathname.slice(packageParts.length);
+          const versionMatch = afterPackage.match(/^@[^/]+(.*)$/);
+          subpath = versionMatch?.[1] ?? "";
+        }
+      } else {
+        if (pathname.includes("/")) {
+          const packageWithVersion = pathname.split("/")[0];
+          const restPath = pathname.slice(packageWithVersion.length);
+          if (restPath.startsWith("/")) {
+            subpath = restPath;
+          }
+        }
+      }
+      return subpath ? mapping + subpath : mapping;
+    }
+  }
   if (specifier.endsWith(".js") || specifier.endsWith(".mjs") || specifier.endsWith(".cjs")) {
     const base = specifier.replace(/\.(m|c)?js$/, "");
     if (importMap.imports?.[base]) {
@@ -5250,13 +6318,22 @@ function resolveImport(specifier, importMap, scope) {
 
 // src/module-system/import-map/transformer.ts
 init_deno_env();
+function shouldResolve(specifier, options) {
+  if (specifier.startsWith("https://esm.sh/") || specifier.startsWith("http://esm.sh/")) {
+    return true;
+  }
+  const isBare = !specifier.startsWith("http") && !specifier.startsWith("/") && !specifier.startsWith(".");
+  if (isBare && !options?.resolveBare) {
+    return false;
+  }
+  return true;
+}
 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) {
+      if (!shouldResolve(specifier, options)) {
         return `${prefix}"${specifier}"`;
       }
       const resolved = resolveImport(specifier, importMap, scope);
@@ -5266,8 +6343,7 @@ function transformImportsWithMap(code, importMap, scope, options) {
   transformedCode = transformedCode.replace(
     /from\s+["']([^"']+)["']/g,
     (match, specifier) => {
-      const isBare = !specifier.startsWith("http") && !specifier.startsWith("/") && !specifier.startsWith(".");
-      if (isBare && !options?.resolveBare) {
+      if (!shouldResolve(specifier, options)) {
         return match;
       }
       const resolved = resolveImport(specifier, importMap, scope);
@@ -5290,28 +6366,2157 @@ 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 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;
-var REACT_IMPORT_PATTERN = /import\s+.*React.*\s+from\s+['"]react['"]/;
-var HTTP_IMPORT_PATTERN = /['"]https?:\/\/[^'"]+['"]/;
-var ESBUILD_JSX_FACTORY = "React.createElement";
-var ESBUILD_JSX_FRAGMENT = "React.Fragment";
-var HTTP_MODULE_FETCH_TIMEOUT_MS2 = 3e4;
-var _resolvedPaths = {};
-async function resolveNodePackage(packageSpec) {
-  if (!IS_TRUE_NODE)
-    return null;
-  if (packageSpec in _resolvedPaths)
-    return _resolvedPaths[packageSpec];
-  try {
-    const { createRequire } = await import("node:module");
-    const require2 = createRequire(import.meta.url);
-    const resolved = require2.resolve(packageSpec);
-    _resolvedPaths[packageSpec] = resolved;
-    return resolved;
+init_fs();
+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/pipeline/index.ts
+init_deno_env();
+
+// 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((error) => {
+      logger.debug("[TransformCache] Redis set failed", { key, error });
+    });
+  }
+}
+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/pipeline/index.ts
+init_utils();
+
+// src/build/transforms/pipeline/context.ts
+init_deno_env();
+
+// 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";
+  if (filePath.endsWith(".css"))
+    return "css";
+  if (filePath.endsWith(".json"))
+    return "json";
+  return "tsx";
+}
+
+// src/build/transforms/pipeline/context.ts
+async function createTransformContext(source, filePath, projectDir, options) {
+  const contentHash = await computeContentHash2(source);
+  const target = options.ssr ? "ssr" : "browser";
+  return {
+    code: source,
+    originalSource: source,
+    filePath,
+    projectDir,
+    projectId: options.projectId,
+    target,
+    dev: options.dev ?? true,
+    contentHash,
+    moduleServerUrl: options.moduleServerUrl,
+    vendorBundleHash: options.vendorBundleHash,
+    apiBaseUrl: options.apiBaseUrl,
+    jsxImportSource: options.jsxImportSource ?? "react",
+    timing: /* @__PURE__ */ new Map(),
+    debug: false,
+    metadata: /* @__PURE__ */ new Map()
+  };
+}
+function recordStageTiming(ctx, stage, startTime) {
+  ctx.timing.set(stage, performance.now() - startTime);
+}
+function getTotalTiming(ctx) {
+  let total = 0;
+  for (const ms of ctx.timing.values()) {
+    total += ms;
+  }
+  return total;
+}
+function formatTimingLog(ctx) {
+  const stageNames = [
+    "parse",
+    "compile",
+    "aliases",
+    "react",
+    "context",
+    "relative",
+    "bare",
+    "finalize"
+  ];
+  const result = {
+    file: ctx.filePath.slice(-40),
+    target: ctx.target
+  };
+  for (const [stage, ms] of ctx.timing) {
+    const name = stageNames[stage] ?? `stage${stage}`;
+    result[`${name}Ms`] = ms.toFixed(1);
+  }
+  result.totalMs = getTotalTiming(ctx).toFixed(1);
+  return result;
+}
+function isSSR(ctx) {
+  return ctx.target === "ssr";
+}
+function isBrowser(ctx) {
+  return ctx.target === "browser";
+}
+function isMDX(ctx) {
+  return ctx.filePath.endsWith(".mdx");
+}
+
+// src/build/transforms/pipeline/stages/index.ts
+init_deno_env();
+
+// src/build/transforms/pipeline/stages/parse.ts
+init_deno_env();
+
+// 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 text = toString(node);
+      const id = slugger.slug(text);
+      if (!node.data) {
+        node.data = {};
+      }
+      if (!node.data.hProperties) {
+        node.data.hProperties = {};
+      }
+      node.data.hProperties.id = id;
+      headings.push({
+        text,
+        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/rehype-mermaid.ts
+init_deno_env();
+import { visit as visit4 } from "unist-util-visit";
+function rehypeMermaid() {
+  return (tree) => {
+    visit4(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 text = "";
+  for (const child of node.children) {
+    if (child.type === "text") {
+      text += child.value;
+    } else if (child.type === "element") {
+      text += extractText(child);
+    }
+  }
+  return text.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 (error) {
+    serverLogger.warn(
+      `Failed to load ${pluginType} plugins from config`,
+      { error: error instanceof Error ? error.message : String(error) }
+    );
+    return [];
+  }
+}
+async function getRemarkPlugins(projectDir, adapter) {
+  const defaultPlugins = [
+    remarkGfm,
+    remarkFrontmatter,
+    // remarkAddNodeId as PluginEntry,
+    remarkMdxHeadings,
+    remarkMdxRemoveParagraphs,
+    remarkCodeBlocks,
+    remarkMdxImports
+  ];
+  if (adapter) {
+    try {
+      const userPlugins = await loadUserPlugins(projectDir, adapter, "remark");
+      return [...defaultPlugins, ...userPlugins];
+    } catch (error) {
+      serverLogger.error(
+        "Error loading user remark plugins",
+        { error: error instanceof Error ? error.message : String(error) }
+      );
+    }
+  }
+  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 (error) {
+      serverLogger.error(
+        "Error loading user rehype plugins",
+        { error: error instanceof Error ? error.message : String(error) }
+      );
+    }
+  }
+  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 join3, 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(join3(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();
+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: false,
+      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 (error) {
+    rendererLogger.error("[MDX Compiler] Compilation failed:", {
+      filePath,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    throw toError(createError({
+      type: "build",
+      message: `MDX compilation error: ${error instanceof Error ? error.message : String(error)} | file: ${filePath || "<memory>"}`
+    }));
+  }
+}
+
+// src/build/transforms/pipeline/types.ts
+init_deno_env();
+
+// src/build/transforms/pipeline/stages/parse.ts
+var parsePlugin = {
+  name: "parse-mdx",
+  stage: 0 /* PARSE */,
+  condition: isMDX,
+  async transform(ctx) {
+    const mdxTarget = isSSR(ctx) ? "server" : "browser";
+    const mdxBaseUrl = isSSR(ctx) ? void 0 : ctx.moduleServerUrl;
+    const result = await compileMDXRuntime(
+      ctx.dev ? "development" : "production",
+      ctx.projectDir,
+      ctx.code,
+      void 0,
+      ctx.filePath,
+      mdxTarget,
+      mdxBaseUrl
+    );
+    if (result.frontmatter) {
+      ctx.metadata.set("frontmatter", result.frontmatter);
+    }
+    return result.compiledCode;
+  }
+};
+
+// src/build/transforms/pipeline/stages/compile.ts
+init_deno_env();
+import * as esbuild from "esbuild/mod.js";
+init_utils();
+var compilePlugin = {
+  name: "esbuild-compile",
+  stage: 1 /* COMPILE */,
+  async transform(ctx) {
+    const loader = getLoaderFromPath(ctx.filePath);
+    try {
+      const result = await esbuild.transform(ctx.code, {
+        loader,
+        format: "esm",
+        target: "es2020",
+        jsx: "automatic",
+        jsxImportSource: ctx.jsxImportSource,
+        minify: !ctx.dev,
+        sourcemap: ctx.dev ? "inline" : false,
+        treeShaking: !ctx.dev,
+        // Disable in dev mode to preserve import errors
+        keepNames: true
+      });
+      let code = result.code;
+      if (ctx.filePath.endsWith(".mdx")) {
+        if (/\bconst\s+MDXLayout\b/.test(code) && !/export\s+\{[^}]*MDXLayout/.test(code)) {
+          code += "\nexport { MDXLayout };\n";
+        }
+      }
+      return code;
+    } catch (transformError) {
+      const sourcePreview = ctx.code.split("\n").slice(0, 10).map((line, i) => `${String(i + 1).padStart(3, " ")}| ${line}`).join("\n");
+      rendererLogger.error("[ESM-TRANSFORM] Transform failed", {
+        filePath: ctx.filePath,
+        loader,
+        sourceLength: ctx.code.length,
+        isMdx: ctx.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 ${ctx.filePath} (loader: ${loader}): ${errorMsg}`);
+    }
+  }
+};
+
+// src/build/transforms/pipeline/stages/resolve-aliases.ts
+init_deno_env();
+
+// src/build/transforms/esm/path-resolver.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;
+var HTTP_URL_PATTERN = /(['"`])(https?:\/\/[^'"`\n]+)\1/g;
+function maskHttpUrls(code) {
+  const urlMap = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const masked = code.replace(HTTP_URL_PATTERN, (_match, quote, url) => {
+    const placeholder = `__VFURL_${counter++}__`;
+    urlMap.set(placeholder, url);
+    return `${quote}${placeholder}${quote}`;
+  });
+  return { masked, urlMap };
+}
+function unmaskHttpUrls(code, urlMap) {
+  let result = code;
+  for (const [placeholder, url] of urlMap) {
+    result = result.replaceAll(placeholder, url);
+  }
+  return result;
+}
+async function initLexer() {
+  if (!initPromise) {
+    const anyInit = init;
+    initPromise = typeof anyInit === "function" ? anyInit() : anyInit;
+  }
+  await initPromise;
+}
+async function parseImports(code) {
+  await initLexer();
+  const { masked, urlMap } = maskHttpUrls(code);
+  const [imports] = parse(masked);
+  if (urlMap.size === 0) {
+    return imports;
+  }
+  return imports.map((imp) => {
+    if (imp.n) {
+      const restoredN = unmaskHttpUrls(imp.n, urlMap);
+      if (restoredN !== imp.n) {
+        return { ...imp, n: restoredN };
+      }
+    }
+    return imp;
+  });
+}
+async function replaceSpecifiers(code, replacer) {
+  await initLexer();
+  const { masked, urlMap } = maskHttpUrls(code);
+  const [imports] = parse(masked);
+  let result = masked;
+  for (let i = imports.length - 1; i >= 0; i--) {
+    const imp = imports[i];
+    if (!imp)
+      continue;
+    if (imp.n === void 0)
+      continue;
+    const originalSpecifier = unmaskHttpUrls(imp.n, urlMap);
+    const replacement = replacer(originalSpecifier, imp.d > -1);
+    if (replacement && replacement !== originalSpecifier) {
+      const before = result.substring(0, imp.s);
+      const after = result.substring(imp.e);
+      result = before + replacement + after;
+    }
+  }
+  return unmaskHttpUrls(result, urlMap);
+}
+async function rewriteImports(code, rewriter) {
+  await initLexer();
+  const { masked, urlMap } = maskHttpUrls(code);
+  const [imports] = parse(masked);
+  let result = masked;
+  for (let i = imports.length - 1; i >= 0; i--) {
+    const imp = imports[i];
+    if (!imp)
+      continue;
+    const unmaskedImp = imp.n ? { ...imp, n: unmaskHttpUrls(imp.n, urlMap) } : imp;
+    const statement = unmaskHttpUrls(masked.substring(imp.ss, imp.se), urlMap);
+    const replacement = rewriter(unmaskedImp, statement);
+    if (replacement !== null) {
+      const before = result.substring(0, imp.ss);
+      const after = result.substring(imp.se);
+      result = before + replacement + after;
+    }
+  }
+  return unmaskHttpUrls(result, urlMap);
+}
+
+// src/build/transforms/esm/path-resolver.ts
+init_utils();
+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;
+    })
+  );
+}
+function blockExternalUrlImports(code, _filePath) {
+  return Promise.resolve({ code, 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/pipeline/stages/resolve-aliases.ts
+var resolveAliasesPlugin = {
+  name: "resolve-aliases",
+  stage: 2 /* RESOLVE_ALIASES */,
+  async transform(ctx) {
+    let code = ctx.code;
+    code = await resolvePathAliases(code, ctx.filePath, ctx.projectDir, isSSR(ctx));
+    const apiBaseUrl = ctx.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: isSSR(ctx)
+    });
+    return code;
+  }
+};
+
+// src/build/transforms/pipeline/stages/resolve-react.ts
+init_deno_env();
+
+// src/build/transforms/esm/react-imports.ts
+init_deno_env();
+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}`;
+}
+function getVeryfrontExportPath(name) {
+  const currentDir = new URL(".", import.meta.url).pathname;
+  const srcDir = currentDir.replace(/\/build\/transforms\/esm\/?$/, "");
+  return `file://${srcDir}/exports/${name}.ts`;
+}
+async function resolveReactImports(code, forSSR = false) {
+  if (forSSR) {
+    const ssrImports = {
+      // AI modules - file:// URLs for local resolution
+      "veryfront/ai/react": getVeryfrontAIReactPath(),
+      "veryfront/ai/components": getVeryfrontAIReactPath("components/index.ts"),
+      "veryfront/ai/primitives": getVeryfrontAIReactPath("primitives/index.ts"),
+      // Framework exports - file:// URLs for local resolution
+      "veryfront/head": getVeryfrontExportPath("head"),
+      "veryfront/router": getVeryfrontExportPath("router"),
+      "veryfront/context": getVeryfrontExportPath("context"),
+      "veryfront/fonts": getVeryfrontExportPath("fonts")
+    };
+    return replaceSpecifiers(code, (specifier) => {
+      return ssrImports[specifier] || null;
+    });
+  }
+  const reactImports = getReactImportMap2();
+  return replaceSpecifiers(code, (specifier) => {
+    return reactImports[specifier] || null;
+  });
+}
+var IMPORT_MAP_PACKAGES = [
+  "@tanstack/react-query",
+  "@tanstack/query-core",
+  "next-themes",
+  "framer-motion",
+  "react-hook-form"
+];
+function extractPackageFromEsmSh(url) {
+  if (!url.startsWith("https://esm.sh/") && !url.startsWith("http://esm.sh/")) {
+    return null;
+  }
+  let path = url.replace(/^https?:\/\/esm\.sh\//, "");
+  path = path.replace(/^v\d+\//, "");
+  if (path.startsWith("@")) {
+    const match = path.match(/^(@[^/]+\/[^@/?]+)/);
+    return match?.[1] ?? null;
+  } else {
+    const match = path.match(/^([^@/?]+)/);
+    return match?.[1] ?? null;
+  }
+}
+function addDepsToEsmShUrls(code, _forSSR = false) {
+  return Promise.resolve(replaceSpecifiers(code, (specifier) => {
+    if (specifier.startsWith("https://esm.sh/") && !specifier.includes(`react@${REACT_VERSION}`)) {
+      const packageName = extractPackageFromEsmSh(specifier);
+      if (packageName && IMPORT_MAP_PACKAGES.includes(packageName)) {
+        return packageName;
+      }
+      const hasQuery = specifier.includes("?");
+      if (hasQuery) {
+        return null;
+      }
+      return `${specifier}?external=react,react-dom&target=es2022`;
+    }
+    return null;
+  }));
+}
+
+// src/build/transforms/pipeline/stages/resolve-react.ts
+var resolveReactPlugin = {
+  name: "resolve-react",
+  stage: 3 /* RESOLVE_REACT */,
+  async transform(ctx) {
+    let code = ctx.code;
+    code = await resolveReactImports(code, isSSR(ctx));
+    code = await addDepsToEsmShUrls(code, isSSR(ctx));
+    if (ctx.dev && isBrowser(ctx)) {
+      code = code.replace(
+        /(['"])https?:\/\/[a-zA-Z0-9-]+\.(?:com|org|net|io|dev|app|veryfront\.com)\1/g,
+        "location.origin"
+      );
+    }
+    return code;
+  }
+};
+
+// src/build/transforms/pipeline/stages/resolve-context.ts
+init_deno_env();
+function buildContextImportMap(ssr) {
+  const map = {};
+  for (const pkg of CONTEXT_PACKAGE_NAMES) {
+    map[pkg] = ssr ? getContextPackageUrlSSR(pkg) : getContextPackageUrlBrowser(pkg);
+  }
+  return map;
+}
+var resolveContextPlugin = {
+  name: "resolve-context",
+  stage: 4 /* RESOLVE_CONTEXT */,
+  async transform(ctx) {
+    const importMap = buildContextImportMap(ctx.target === "ssr");
+    return await replaceSpecifiers(ctx.code, (specifier) => {
+      if (isContextPackage(specifier)) {
+        return importMap[specifier] || null;
+      }
+      if (specifier.startsWith("https://esm.sh/")) {
+        const packageName = extractPackageFromEsmSh2(specifier);
+        if (packageName && isContextPackage(packageName)) {
+          return importMap[packageName] || null;
+        }
+      }
+      return null;
+    });
+  }
+};
+function extractPackageFromEsmSh2(url) {
+  if (!url.startsWith("https://esm.sh/") && !url.startsWith("http://esm.sh/")) {
+    return null;
+  }
+  let path = url.replace(/^https?:\/\/esm\.sh\//, "");
+  path = path.replace(/^v\d+\//, "");
+  if (path.startsWith("@")) {
+    const match = path.match(/^(@[^/]+\/[^@/?]+)/);
+    return match?.[1] ?? null;
+  } else {
+    const match = path.match(/^([^@/?]+)/);
+    return match?.[1] ?? null;
+  }
+}
+
+// src/build/transforms/pipeline/stages/ssr-http-stub.ts
+init_deno_env();
+function isHttpImport(specifier) {
+  if (!specifier)
+    return false;
+  return specifier.startsWith("http://") || specifier.startsWith("https://");
+}
+function isBrowserOnlyModule(specifier) {
+  if (specifier.includes("video.js") || specifier.includes("video-js"))
+    return true;
+  if (specifier.includes("videojs"))
+    return true;
+  if (specifier.includes("gsap"))
+    return true;
+  if (specifier.includes("three"))
+    return true;
+  if (specifier.includes("mapbox"))
+    return true;
+  if (specifier.includes("leaflet"))
+    return true;
+  return false;
+}
+function generateStub(imp, statement) {
+  if (!imp.n || !isHttpImport(imp.n))
+    return null;
+  if (!isBrowserOnlyModule(imp.n))
+    return null;
+  if (imp.d > -1)
+    return null;
+  const trimmed = statement.trim();
+  if (/^import\s+['"`]/.test(trimmed)) {
+    return `/* SSR stub: ${trimmed} */`;
+  }
+  const fromIndex = trimmed.lastIndexOf(" from ");
+  if (fromIndex === -1)
+    return null;
+  const importClause = trimmed.slice(6, fromIndex).trim();
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(importClause)) {
+    return `const ${importClause} = null; /* SSR stub for ${imp.n} */`;
+  }
+  const namespaceMatch = importClause.match(/^\*\s+as\s+([a-zA-Z_$][a-zA-Z0-9_$]*)$/);
+  if (namespaceMatch) {
+    return `const ${namespaceMatch[1]} = {}; /* SSR stub for ${imp.n} */`;
+  }
+  const namedMatch = importClause.match(/^\{([^}]+)\}$/);
+  if (namedMatch?.[1]) {
+    const names = namedMatch[1].split(",").map((n) => {
+      const parts = n.trim().split(/\s+as\s+/);
+      return parts[parts.length - 1]?.trim() ?? "";
+    });
+    const stubs = names.map((n) => `${n} = null`).join(", ");
+    return `const ${stubs}; /* SSR stub for ${imp.n} */`;
+  }
+  const mixedMatch = importClause.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)\s*,\s*\{([^}]+)\}$/);
+  if (mixedMatch?.[1] && mixedMatch[2]) {
+    const defaultName = mixedMatch[1];
+    const names = mixedMatch[2].split(",").map((n) => {
+      const parts = n.trim().split(/\s+as\s+/);
+      return parts[parts.length - 1]?.trim() ?? "";
+    });
+    const allNames = [defaultName, ...names].map((n) => `${n} = null`).join(", ");
+    return `const ${allNames}; /* SSR stub for ${imp.n} */`;
+  }
+  return null;
+}
+var ssrHttpStubPlugin = {
+  name: "ssr-http-stub",
+  stage: 4 /* RESOLVE_CONTEXT */ + 1,
+  // Run just after resolve-context, before resolve-relative
+  // No condition needed - this plugin is only added to SSR_PIPELINE
+  async transform(ctx) {
+    const imports = await parseImports(ctx.code);
+    const needsStubbing = imports.some(
+      (imp) => imp.n && isHttpImport(imp.n) && isBrowserOnlyModule(imp.n) && imp.d === -1
+    );
+    if (!needsStubbing) {
+      return ctx.code;
+    }
+    return await rewriteImports(ctx.code, (imp, statement) => generateStub(imp, statement));
+  }
+};
+
+// src/build/transforms/pipeline/stages/resolve-relative.ts
+init_deno_env();
+init_utils();
+var resolveRelativePlugin = {
+  name: "resolve-relative",
+  stage: 5 /* RESOLVE_RELATIVE */,
+  async transform(ctx) {
+    let code = ctx.code;
+    if (isSSR(ctx)) {
+      const urlBlockResult = await blockExternalUrlImports(code, ctx.filePath);
+      code = urlBlockResult.code;
+      if (urlBlockResult.blockedUrls.length > 0) {
+        rendererLogger.warn("[PIPELINE:resolve-relative] Blocked external URL imports in SSR mode", {
+          file: ctx.filePath.slice(-60),
+          blockedUrls: urlBlockResult.blockedUrls
+        });
+      }
+      code = await resolveRelativeImportsForSSR(code);
+      code = await resolveVeryfrontImports(code);
+    } else if (isBrowser(ctx)) {
+      code = await resolveRelativeImports(
+        code,
+        ctx.filePath,
+        ctx.projectDir,
+        ctx.moduleServerUrl
+      );
+    }
+    return code;
+  }
+};
+
+// src/build/transforms/pipeline/stages/resolve-bare.ts
+init_deno_env();
+
+// 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 htmlImportMapPackages = [
+    "@tanstack/react-query",
+    "@tanstack/query-core",
+    "next-themes",
+    "framer-motion"
+  ];
+  const importMap = {
+    "react": `https://esm.sh/react@${REACT_DEFAULT_VERSION}?target=es2022`,
+    "react-dom": `https://esm.sh/react-dom@${REACT_DEFAULT_VERSION}?target=es2022`,
+    "react-dom/client": `https://esm.sh/react-dom@${REACT_DEFAULT_VERSION}/client?target=es2022`,
+    "react-dom/server": `https://esm.sh/react-dom@${REACT_DEFAULT_VERSION}/server?target=es2022`,
+    "react/jsx-runtime": `https://esm.sh/react@${REACT_DEFAULT_VERSION}/jsx-runtime?target=es2022`,
+    "react/jsx-dev-runtime": `https://esm.sh/react@${REACT_DEFAULT_VERSION}/jsx-dev-runtime?target=es2022`
+    // 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);
+    const matchesImportMapPackage = htmlImportMapPackages.some(
+      (pkg) => normalized === pkg || normalized.startsWith(`${pkg}/`)
+    );
+    if (matchesImportMapPackage) {
+      return null;
+    }
+    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}?external=react,react-dom&target=es2022`;
+  }));
+}
+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/pipeline/stages/resolve-bare.ts
+var resolveBarePlugin = {
+  name: "resolve-bare",
+  stage: 6 /* RESOLVE_BARE */,
+  async transform(ctx) {
+    let code = ctx.code;
+    if (isSSR(ctx)) {
+      code = transformImportsWithMap(
+        code,
+        getDefaultImportMap(),
+        void 0,
+        { resolveBare: true }
+      );
+    } else if (isBrowser(ctx)) {
+      if (ctx.moduleServerUrl && ctx.vendorBundleHash) {
+        code = await rewriteVendorImports(code, ctx.moduleServerUrl, ctx.vendorBundleHash);
+      } else {
+        code = await rewriteBareImports(code, ctx.moduleServerUrl);
+      }
+    }
+    return code;
+  }
+};
+
+// src/build/transforms/pipeline/stages/finalize.ts
+init_deno_env();
+
+// src/build/transforms/esm/http-bundler.ts
+init_deno_env();
+init_utils();
+var LOG_PREFIX = "[HTTP-HANDLER]";
+function hasHttpImports(code) {
+  return /['"]https?:\/\/[^'"]+['"]/.test(code);
+}
+function getReactAliases() {
+  const urls = getReactUrls();
+  return {
+    // Bare specifiers
+    "react": urls.react,
+    "react-dom": urls["react-dom"],
+    "react/jsx-runtime": urls["react/jsx-runtime"],
+    "react/jsx-dev-runtime": urls["react/jsx-dev-runtime"],
+    "react-dom/server": urls["react-dom/server"],
+    "react-dom/client": urls["react-dom/client"],
+    // npm: specifiers (Deno import map resolution produces these)
+    "npm:react": urls.react,
+    [`npm:react@${REACT_VERSION}`]: urls.react,
+    [`npm:react@${REACT_VERSION}/jsx-runtime`]: urls["react/jsx-runtime"],
+    [`npm:react@${REACT_VERSION}/jsx-dev-runtime`]: urls["react/jsx-dev-runtime"],
+    "npm:react-dom": urls["react-dom"],
+    [`npm:react-dom@${REACT_VERSION}`]: urls["react-dom"],
+    [`npm:react-dom@${REACT_VERSION}/server`]: urls["react-dom/server"],
+    [`npm:react-dom@${REACT_VERSION}/client`]: urls["react-dom/client"]
+  };
+}
+function stripDenoShim(code) {
+  const isDeno3 = typeof Deno !== "undefined";
+  if (!isDeno3)
+    return code;
+  return code.replace(
+    /globalThis\.Deno\s*=\s*globalThis\.Deno\s*\|\|\s*\{[\s\S]*?env:\s*\{[\s\S]*?\}\s*\};?/g,
+    "/* Deno shim stripped */"
+  );
+}
+function createHTTPPlugin() {
+  return { name: "vf-http-noop", setup: () => {
+  } };
+}
+function bundleHttpImports(code, _tempDir, hash) {
+  const has = hasHttpImports(code);
+  rendererLogger.debug(`${LOG_PREFIX} Check: hasHttp=${has}, hash=${hash.slice(0, 8)}`);
+  if (!has)
+    return code;
+  const isDeno3 = typeof Deno !== "undefined";
+  if (isDeno3) {
+    rendererLogger.debug(`${LOG_PREFIX} Deno detected - passing through HTTP imports`);
+    return code;
+  }
+  rendererLogger.warn(`${LOG_PREFIX} Non-Deno runtime detected - HTTP imports may fail`);
+  return code;
+}
+
+// src/build/transforms/pipeline/stages/finalize.ts
+init_process();
+import { join as join4 } from "node:path";
+var finalizePlugin = {
+  name: "finalize",
+  stage: 7 /* FINALIZE */,
+  transform(ctx) {
+    let code = ctx.code;
+    if (isSSR(ctx)) {
+      const httpCacheDir = join4(cwd(), ".cache", "veryfront-http-bundle");
+      code = bundleHttpImports(code, httpCacheDir, ctx.contentHash);
+    }
+    return code;
+  }
+};
+
+// src/build/transforms/pipeline/index.ts
+var SSR_PIPELINE = [
+  parsePlugin,
+  compilePlugin,
+  resolveAliasesPlugin,
+  resolveReactPlugin,
+  resolveContextPlugin,
+  ssrHttpStubPlugin,
+  // Stub browser-only HTTP imports during SSR
+  resolveRelativePlugin,
+  resolveBarePlugin,
+  finalizePlugin
+];
+var BROWSER_PIPELINE = [
+  parsePlugin,
+  compilePlugin,
+  resolveAliasesPlugin,
+  resolveReactPlugin,
+  resolveContextPlugin,
+  resolveRelativePlugin,
+  resolveBarePlugin,
+  finalizePlugin
+];
+async function runPipeline(source, filePath, projectDir, options, config) {
+  const transformStart = performance.now();
+  const ctx = await createTransformContext(source, filePath, projectDir, options);
+  ctx.debug = config?.debug ?? false;
+  const cacheKey = generateCacheKey(
+    options.projectId,
+    filePath,
+    ctx.contentHash,
+    options.ssr ?? false
+  );
+  const cached = getCachedTransform(cacheKey);
+  if (cached) {
+    return {
+      code: cached.code,
+      contentHash: ctx.contentHash,
+      timing: /* @__PURE__ */ new Map(),
+      totalMs: performance.now() - transformStart,
+      cached: true
+    };
+  }
+  const basePipeline = options.ssr ? SSR_PIPELINE : BROWSER_PIPELINE;
+  const pipeline = config?.plugins ? [...basePipeline, ...config.plugins].sort((a, b) => a.stage - b.stage) : basePipeline;
+  for (const plugin of pipeline) {
+    if (plugin.condition && !plugin.condition(ctx)) {
+      continue;
+    }
+    const stageStart = performance.now();
+    try {
+      ctx.code = await plugin.transform(ctx);
+    } catch (error) {
+      rendererLogger.error(`[PIPELINE:${plugin.name}] Stage failed`, {
+        file: filePath.slice(-60),
+        stage: plugin.name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+    recordStageTiming(ctx, plugin.stage, stageStart);
+  }
+  setCachedTransform(cacheKey, ctx.code, ctx.contentHash);
+  const totalMs = performance.now() - transformStart;
+  if (ctx.debug) {
+    rendererLogger.debug("[PIPELINE] Transform complete", formatTimingLog(ctx));
+  }
+  return {
+    code: ctx.code,
+    contentHash: ctx.contentHash,
+    timing: ctx.timing,
+    totalMs,
+    cached: false
+  };
+}
+async function transformToESM(source, filePath, projectDir, _adapter, options) {
+  if (filePath.endsWith(".css") || filePath.endsWith(".json")) {
+    return source;
+  }
+  const result = await runPipeline(source, filePath, projectDir, options);
+  return result.code;
+}
+
+// src/rendering/ssr-globals.ts
+init_deno_env();
+var ssrGlobalsInitialized = false;
+var createDocumentStub = () => ({
+  // Fullscreen API (video.js, etc.)
+  exitFullscreen: void 0,
+  webkitExitFullscreen: void 0,
+  mozCancelFullScreen: void 0,
+  msExitFullscreen: void 0,
+  fullscreenElement: null,
+  webkitFullscreenElement: null,
+  mozFullScreenElement: null,
+  msFullscreenElement: null,
+  // DOM methods (return null/empty to indicate not found)
+  createElement: () => createElementStub(),
+  createElementNS: () => createElementStub(),
+  createTextNode: () => ({ textContent: "" }),
+  querySelector: () => null,
+  querySelectorAll: () => [],
+  getElementById: () => null,
+  getElementsByClassName: () => [],
+  getElementsByTagName: () => [],
+  getElementsByName: () => [],
+  // Document properties
+  documentElement: {
+    style: {},
+    classList: { add: () => {
+    }, remove: () => {
+    }, contains: () => false }
+  },
+  body: {
+    style: {},
+    classList: { add: () => {
+    }, remove: () => {
+    }, contains: () => false },
+    appendChild: () => {
+    }
+  },
+  head: { appendChild: () => {
+  }, removeChild: () => {
+  } },
+  readyState: "complete",
+  cookie: "",
+  domain: "",
+  referrer: "",
+  title: "",
+  URL: "",
+  location: { href: "", pathname: "/", search: "", hash: "" },
+  // Event handling (no-op)
+  addEventListener: () => {
+  },
+  removeEventListener: () => {
+  },
+  dispatchEvent: () => true,
+  // Style/CSS
+  styleSheets: [],
+  adoptedStyleSheets: []
+});
+var createElementStub = () => ({
+  style: {},
+  classList: { add: () => {
+  }, remove: () => {
+  }, contains: () => false, toggle: () => false },
+  dataset: {},
+  setAttribute: () => {
+  },
+  getAttribute: () => null,
+  removeAttribute: () => {
+  },
+  hasAttribute: () => false,
+  appendChild: () => {
+  },
+  removeChild: () => {
+  },
+  insertBefore: () => {
+  },
+  replaceChild: () => {
+  },
+  cloneNode: () => createElementStub(),
+  addEventListener: () => {
+  },
+  removeEventListener: () => {
+  },
+  querySelector: () => null,
+  querySelectorAll: () => [],
+  getBoundingClientRect: () => ({ top: 0, left: 0, right: 0, bottom: 0, width: 0, height: 0 }),
+  offsetWidth: 0,
+  offsetHeight: 0,
+  scrollWidth: 0,
+  scrollHeight: 0,
+  clientWidth: 0,
+  clientHeight: 0,
+  innerHTML: "",
+  outerHTML: "",
+  textContent: "",
+  innerText: "",
+  children: [],
+  childNodes: [],
+  parentNode: null,
+  parentElement: null,
+  nextSibling: null,
+  previousSibling: null,
+  firstChild: null,
+  lastChild: null
+});
+var createWindowStub = () => ({
+  // Common properties
+  document: createDocumentStub(),
+  navigator: {
+    userAgent: "SSR",
+    language: "en-US",
+    languages: ["en-US"],
+    platform: "SSR",
+    vendor: "",
+    onLine: true,
+    cookieEnabled: false,
+    mediaDevices: { getUserMedia: () => Promise.reject(new Error("SSR")) }
+  },
+  location: {
+    href: "",
+    pathname: "/",
+    search: "",
+    hash: "",
+    origin: "",
+    protocol: "https:",
+    host: "",
+    hostname: "",
+    port: "",
+    assign: () => {
+    },
+    replace: () => {
+    },
+    reload: () => {
+    }
+  },
+  history: {
+    length: 0,
+    state: null,
+    pushState: () => {
+    },
+    replaceState: () => {
+    },
+    go: () => {
+    },
+    back: () => {
+    },
+    forward: () => {
+    }
+  },
+  // Dimensions (common for responsive checks)
+  innerWidth: 1024,
+  innerHeight: 768,
+  outerWidth: 1024,
+  outerHeight: 768,
+  screenX: 0,
+  screenY: 0,
+  pageXOffset: 0,
+  pageYOffset: 0,
+  scrollX: 0,
+  scrollY: 0,
+  devicePixelRatio: 1,
+  // Timers (use real implementations if available)
+  setTimeout: globalThis.setTimeout,
+  clearTimeout: globalThis.clearTimeout,
+  setInterval: globalThis.setInterval,
+  clearInterval: globalThis.clearInterval,
+  requestAnimationFrame: (cb) => globalThis.setTimeout(cb, 16),
+  cancelAnimationFrame: globalThis.clearTimeout,
+  // Storage (no-op)
+  localStorage: {
+    getItem: () => null,
+    setItem: () => {
+    },
+    removeItem: () => {
+    },
+    clear: () => {
+    },
+    length: 0,
+    key: () => null
+  },
+  sessionStorage: {
+    getItem: () => null,
+    setItem: () => {
+    },
+    removeItem: () => {
+    },
+    clear: () => {
+    },
+    length: 0,
+    key: () => null
+  },
+  // Events
+  addEventListener: () => {
+  },
+  removeEventListener: () => {
+  },
+  dispatchEvent: () => true,
+  // Media queries
+  matchMedia: (query) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: () => {
+    },
+    removeListener: () => {
+    },
+    addEventListener: () => {
+    },
+    removeEventListener: () => {
+    },
+    dispatchEvent: () => true
+  }),
+  // Misc
+  getComputedStyle: () => ({
+    getPropertyValue: () => ""
+  }),
+  getSelection: () => null,
+  print: () => {
+  },
+  alert: () => {
+  },
+  confirm: () => false,
+  prompt: () => null,
+  open: () => null,
+  close: () => {
+  },
+  focus: () => {
+  },
+  blur: () => {
+  },
+  scroll: () => {
+  },
+  scrollTo: () => {
+  },
+  scrollBy: () => {
+  },
+  resizeTo: () => {
+  },
+  resizeBy: () => {
+  },
+  moveTo: () => {
+  },
+  moveBy: () => {
+  },
+  // Crypto (basic stub)
+  crypto: globalThis.crypto,
+  // Performance
+  performance: globalThis.performance,
+  // fetch is available in Deno
+  fetch: globalThis.fetch,
+  // URL/URLSearchParams are available in Deno
+  URL: globalThis.URL,
+  URLSearchParams: globalThis.URLSearchParams,
+  // TextEncoder/Decoder are available in Deno
+  TextEncoder: globalThis.TextEncoder,
+  TextDecoder: globalThis.TextDecoder
+});
+function createElementClass(name) {
+  const ElementClass = class {
+  };
+  Object.defineProperty(ElementClass, "name", { value: name });
+  return ElementClass;
+}
+function setupSSRGlobals() {
+  if (ssrGlobalsInitialized)
+    return;
+  if (typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined") {
+    return;
+  }
+  const windowStub = createWindowStub();
+  globalThis.window = windowStub;
+  globalThis.document = windowStub.document;
+  globalThis.navigator = windowStub.navigator;
+  globalThis.location = windowStub.location;
+  globalThis.history = windowStub.history;
+  globalThis.localStorage = windowStub.localStorage;
+  globalThis.sessionStorage = windowStub.sessionStorage;
+  globalThis.matchMedia = windowStub.matchMedia;
+  globalThis.getComputedStyle = windowStub.getComputedStyle;
+  globalThis.requestAnimationFrame = windowStub.requestAnimationFrame;
+  globalThis.cancelAnimationFrame = windowStub.cancelAnimationFrame;
+  globalThis.self = windowStub;
+  if (typeof globalThis.Element === "undefined") {
+    globalThis.Element = createElementClass("Element");
+  }
+  if (typeof globalThis.HTMLElement === "undefined") {
+    globalThis.HTMLElement = createElementClass("HTMLElement");
+  }
+  if (typeof globalThis.SVGElement === "undefined") {
+    globalThis.SVGElement = createElementClass("SVGElement");
+  }
+  if (typeof globalThis.Node === "undefined") {
+    globalThis.Node = createElementClass("Node");
+  }
+  if (typeof globalThis.Text === "undefined") {
+    globalThis.Text = createElementClass("Text");
+  }
+  if (typeof globalThis.Comment === "undefined") {
+    globalThis.Comment = createElementClass("Comment");
+  }
+  if (typeof globalThis.DocumentFragment === "undefined") {
+    globalThis.DocumentFragment = createElementClass(
+      "DocumentFragment"
+    );
+  }
+  ssrGlobalsInitialized = true;
+}
+var originalFetch = globalThis.fetch;
+
+// src/build/transforms/mdx/esm-module-loader.ts
+var IS_TRUE_NODE = isNode && !isDeno;
+var FRAMEWORK_ROOT = new URL("../../../..", import.meta.url).pathname;
+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;
+var REACT_IMPORT_PATTERN = /import\s+.*React.*\s+from\s+['"]react['"]/;
+var ESBUILD_JSX_FACTORY = "React.createElement";
+var ESBUILD_JSX_FRAGMENT = "React.Fragment";
+var _resolvedPaths = {};
+var _localFs = null;
+function getLocalFs() {
+  if (!_localFs) {
+    _localFs = createFileSystem();
+  }
+  return _localFs;
+}
+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 getLocalFs().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 getLocalFs().writeTextFile(indexPath, JSON.stringify(index));
+  } catch (error) {
+    rendererLogger.warn(`${LOG_PREFIX_MDX_LOADER} Failed to save module index`, error);
+  }
+}
+async function resolveNodePackage(packageSpec) {
+  if (!IS_TRUE_NODE)
+    return null;
+  if (packageSpec in _resolvedPaths)
+    return _resolvedPaths[packageSpec];
+  try {
+    const { createRequire } = await import("node:module");
+    const require2 = createRequire(import.meta.url);
+    const resolved = require2.resolve(packageSpec);
+    _resolvedPaths[packageSpec] = resolved;
+    return resolved;
   } catch {
     _resolvedPaths[packageSpec] = null;
     return null;
@@ -5360,98 +8565,537 @@ function hashString(input) {
   }
   return (hash >>> 0).toString(16);
 }
-function createHTTPPluginForMDX() {
-  return {
-    name: "vf-mdx-http-fetch",
-    setup(build) {
-      build.onResolve({ filter: /^(http|https):\/\// }, (args) => ({
-        path: args.path,
-        namespace: "http-url"
-      }));
-      build.onResolve({ filter: /.*/, namespace: "http-url" }, (args) => {
-        if (args.path.startsWith("http://") || args.path.startsWith("https://")) {
-          return { path: args.path, namespace: "http-url" };
-        }
-        try {
-          const resolved = new URL(args.path, args.importer).toString();
-          return { path: resolved, namespace: "http-url" };
-        } catch {
-          return void 0;
-        }
-      });
-      build.onLoad({ filter: /.*/, namespace: "http-url" }, async (args) => {
-        let requestUrl = args.path;
-        try {
-          const u = new URL(args.path);
-          if (u.hostname === "esm.sh") {
-            if (u.pathname.includes("/denonext/")) {
-              u.pathname = u.pathname.replace("/denonext/", "/");
-            }
-            u.searchParams.set("target", "es2020");
-            u.searchParams.set("bundle", "true");
-            requestUrl = u.toString();
-          }
-        } catch {
-        }
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), HTTP_MODULE_FETCH_TIMEOUT_MS2);
-        try {
-          const res = await fetch(requestUrl, {
-            headers: { "user-agent": "Mozilla/5.0 Veryfront/1.0" },
-            signal: controller.signal
-          });
-          clearTimeout(timeout);
-          if (!res.ok) {
-            return {
-              errors: [{ text: `Failed to fetch ${args.path}: ${res.status}` }]
-            };
-          }
-          const text = await res.text();
-          return { contents: text, loader: "js" };
-        } catch (e) {
-          clearTimeout(timeout);
-          return {
-            errors: [{
-              text: `Failed to fetch ${args.path}: ${e instanceof Error ? e.message : String(e)}`
-            }]
-          };
-        }
-      });
-    }
-  };
-}
 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();
+    const adapter = context.adapter ?? await (async () => {
+      const { getAdapter: getAdapter2 } = await Promise.resolve().then(() => (init_detect(), detect_exports));
+      return 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");
+      const localFs2 = getLocalFs();
+      try {
+        await localFs2.mkdir(persistentCacheDir, { recursive: true });
+        context.esmCacheDir = persistentCacheDir;
+        rendererLogger.info(`${LOG_PREFIX_MDX_LOADER} Using persistent cache dir: ${persistentCacheDir}`);
+      } catch {
+        if (IS_TRUE_NODE) {
+          const projectCacheDir = join6(cwd(), "node_modules", ".cache", "veryfront-mdx");
+          await localFs2.mkdir(projectCacheDir, { recursive: true });
+          context.esmCacheDir = projectCacheDir;
+        } else {
+          context.esmCacheDir = await localFs2.makeTempDir({ prefix: "veryfront-mdx-esm-" });
+        }
       }
     }
-    let rewritten;
+    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_NODE) {
-      rewritten = await transformReactImportsToAbsolute(compiledProgramCode);
+      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((resolve) => {
+        resolveDeferred = resolve;
+      });
+      inFlight.set(normalizedPath, fetchPromise);
+      const result2 = await (async () => {
+        const pathCache = await getModulePathCache(context.esmCacheDir);
+        const cachedPath = pathCache.get(normalizedPath);
+        if (cachedPath) {
+          try {
+            const localFs2 = getLocalFs();
+            const stat = await localFs2.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 && filePathWithoutJs.startsWith("lib/")) {
+            const localFs3 = getLocalFs();
+            for (const ext of extensions) {
+              const frameworkPath = join6(FRAMEWORK_ROOT, filePathWithoutJs + ext);
+              try {
+                const stat = await localFs3.stat(frameworkPath);
+                if (stat?.isFile) {
+                  const content = await localFs3.readTextFile(frameworkPath);
+                  sourceCode = content;
+                  actualFilePath = frameworkPath;
+                  rendererLogger.debug(`${LOG_PREFIX_MDX_LOADER} Found framework lib file (fallback)`, {
+                    basePath: filePathWithoutJs,
+                    resolvedPath: frameworkPath
+                  });
+                  break;
+                }
+              } catch {
+              }
+            }
+          }
+          if (!sourceCode || !actualFilePath) {
+            const isProxyMode = adapter.env.get("PROXY_MODE") === "1";
+            if (isProxyMode) {
+              rendererLogger.warn(
+                `${LOG_PREFIX_MDX_LOADER} Direct read failed in proxy mode (module must be pre-loaded): ${filePathWithoutJs}`
+              );
+              return null;
+            }
+            rendererLogger.debug(
+              `${LOG_PREFIX_MDX_LOADER} Direct read failed, falling back to HTTP: ${filePathWithoutJs}`
+            );
+            const port = adapter.env.get("VERYFRONT_DEV_PORT") || adapter.env.get("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();
+            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`);
+            const localFs3 = getLocalFs();
+            try {
+              const stat = await localFs3.stat(cachePath2);
+              if (stat?.isFile) {
+                pathCache.set(normalizedPath, cachePath2);
+                rendererLogger.debug(`${LOG_PREFIX_MDX_LOADER} Content cache hit: ${normalizedPath}`);
+                return cachePath2;
+              }
+            } catch {
+            }
+            await localFs3.mkdir(context.esmCacheDir, { recursive: true });
+            await localFs3.writeTextFile(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;
+          }
+          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 importNamePattern = new RegExp(
+                `import\\s+(?:({[^}]+})|([\\w$]+))\\s*${original.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`
+              );
+              const importMatch = moduleCode.match(importNamePattern);
+              let namedExports = "";
+              if (importMatch) {
+                if (importMatch[1]) {
+                  const names = importMatch[1].replace(/[{}]/g, "").split(",").map((n) => n.trim().split(/\s+as\s+/)[0]?.trim()).filter((n) => !!n);
+                  namedExports = names.map(
+                    (n) => `export const ${n} = () => { console.warn('[Veryfront] Missing export "${n}" from "${nestedPath}"'); return null; };`
+                  ).join("\n");
+                }
+              }
+              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);
+${namedExports}
+`;
+              const stubHash = hashString(`stub:${nestedPath}:${namedExports}`);
+              const stubPath = join6(context.esmCacheDir, `stub-${stubHash}.mjs`);
+              try {
+                await getLocalFs().writeTextFile(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 importNamePattern = new RegExp(
+                `import\\s+(?:({[^}]+})|([\\w$]+))\\s*${original.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`
+              );
+              const importMatch = moduleCode.match(importNamePattern);
+              let namedExports = "";
+              if (importMatch) {
+                if (importMatch[1]) {
+                  const names = importMatch[1].replace(/[{}]/g, "").split(",").map((n) => n.trim().split(/\s+as\s+/)[0]?.trim()).filter((n) => !!n);
+                  namedExports = names.map(
+                    (n) => `export const ${n} = () => { console.warn('[Veryfront] Missing export "${n}" from "${relativePath}"'); return null; };`
+                  ).join("\n");
+                }
+              }
+              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);
+${namedExports}
+`;
+              const stubHash = hashString(`stub:${relativePath}:${namedExports}`);
+              const stubPath = join6(context.esmCacheDir, `stub-${stubHash}.mjs`);
+              try {
+                await getLocalFs().writeTextFile(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`);
+          const localFs2 = getLocalFs();
+          try {
+            const stat = await localFs2.stat(cachePath);
+            if (stat?.isFile) {
+              pathCache.set(normalizedPath, cachePath);
+              rendererLogger.debug(`${LOG_PREFIX_MDX_LOADER} Content cache hit: ${normalizedPath}`);
+              return cachePath;
+            }
+          } catch {
+          }
+          await localFs2.mkdir(context.esmCacheDir, { recursive: true });
+          await localFs2.writeTextFile(cachePath, moduleCode);
+          pathCache.set(normalizedPath, cachePath);
+          await saveModulePathCache(context.esmCacheDir);
+          rendererLogger.debug(
+            `${LOG_PREFIX_MDX_LOADER} Cached vf_module: ${normalizedPath} -> ${cachePath}`
+          );
+          return cachePath;
+        } catch (error) {
+          rendererLogger.warn(`${LOG_PREFIX_MDX_LOADER} Failed to process ${normalizedPath}`, error);
+          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, path };
+      })
+    );
+    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, path } of vfModuleResults) {
+      if (filePath2) {
+        rewritten = rewritten.replace(original, `from "file://${filePath2}"`);
+      } else {
+        const importNamePattern = new RegExp(
+          `import\\s+(?:({[^}]+})|([\\w$]+))\\s*${original.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`
+        );
+        const importMatch = rewritten.match(importNamePattern);
+        let namedExports = "";
+        if (importMatch) {
+          if (importMatch[1]) {
+            const names = importMatch[1].replace(/[{}]/g, "").split(",").map((n) => n.trim().split(/\s+as\s+/)[0]?.trim()).filter((n) => !!n);
+            namedExports = names.map(
+              (n) => `export const ${n} = () => { console.warn('[Veryfront] Missing export "${n}" from "${path}"'); return null; };`
+            ).join("\n");
+          }
+        }
+        const stubCode = `
+// Stub module for missing file: ${path}
+// 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: ${path}. Component "' + prop + '" was not found.');
+    return () => null;
+  },
+  apply() { return null; }
+};
+export default new Proxy(function(){}, handler);
+${namedExports}
+`;
+        const stubHash = hashString(`stub:${path}:${namedExports}`);
+        const stubPath = join6(context.esmCacheDir, `stub-${stubHash}.mjs`);
+        try {
+          await getLocalFs().writeTextFile(stubPath, stubCode);
+          rewritten = rewritten.replace(original, `from "file://${stubPath}"`);
+          rendererLogger.warn(
+            `${LOG_PREFIX_MDX_LOADER} Created stub for missing top-level module: ${path}`
+          );
+        } catch (e) {
+          rendererLogger.error(
+            `${LOG_PREFIX_MDX_LOADER} Failed to create stub for: ${path}`,
+            e
+          );
+        }
+      }
+    }
     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) {
@@ -5462,7 +9106,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,
@@ -5475,8 +9119,8 @@ async function loadModuleESM(compiledProgramCode, context) {
 ${transformed}`;
         }
         const transformedFileName = `jsx-${hashString(filePath2)}.mjs`;
-        const transformedPath = join4(context.esmCacheDir, transformedFileName);
-        await adapter.fs.writeFile(transformedPath, transformed);
+        const transformedPath = join6(context.esmCacheDir, transformedFileName);
+        await getLocalFs().writeTextFile(transformedPath, transformed);
         jsxTransforms.push({
           original: fullMatch,
           transformed: `import ${importClause} from "file://${transformedPath}";`
@@ -5494,12 +9138,18 @@ ${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`);
+    const codeHasHttpImports = hasHttpImports(rewritten);
+    rendererLogger.info(`${LOG_PREFIX_MDX_LOADER} HTTP imports check`, {
+      hasHttpImports: codeHasHttpImports,
+      codePreview: rewritten.substring(0, 500)
+    });
+    if (codeHasHttpImports) {
+      rendererLogger.info(`${LOG_PREFIX_MDX_LOADER} Bundling HTTP imports via esbuild`);
       const { build } = await import("esbuild/mod.js");
-      const tempSourcePath = join4(context.esmCacheDir, `temp-${hashString(rewritten)}.mjs`);
-      await adapter.fs.writeFile(tempSourcePath, rewritten);
+      const tempSourcePath = join6(context.esmCacheDir, `temp-${hashString(rewritten)}.mjs`);
+      await getLocalFs().writeTextFile(tempSourcePath, rewritten);
       try {
+        const reactAliases = getReactAliases();
         const result2 = await build({
           entryPoints: [tempSourcePath],
           bundle: true,
@@ -5507,9 +9157,15 @@ ${transformed}`;
           platform: "neutral",
           target: "es2020",
           write: false,
-          plugins: [createHTTPPluginForMDX()],
-          // Mark npm packages as external so they're not bundled
-          external: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"]
+          plugins: [createHTTPPlugin()],
+          // Use aliases to normalize all React imports to esm.sh URLs
+          alias: reactAliases,
+          // Mark external: React URLs, file:// URLs (local modules), veryfront/* (framework)
+          external: [
+            ...Object.values(reactAliases),
+            "file://*",
+            "veryfront/*"
+          ]
         });
         const bundledCode = result2.outputFiles?.[0]?.text;
         if (bundledCode) {
@@ -5517,8 +9173,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 {
@@ -5533,35 +9189,46 @@ ${transformed}`;
         }
       }
     }
+    rewritten = stripDenoShim(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);
+    const localFs = getLocalFs();
     try {
-      await adapter.fs.mkdir(nsDir, { recursive: true });
+      await localFs.mkdir(nsDir, { recursive: true });
     } catch (e) {
       rendererLogger.debug(
         `${LOG_PREFIX_MDX_RENDERER} mkdir nsDir failed`,
         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);
+      const stat = await localFs.stat(filePath);
       if (!stat?.isFile) {
-        await adapter.fs.writeFile(filePath, rewritten);
+        await localFs.writeTextFile(filePath, rewritten);
       }
     } catch (error) {
       rendererLogger.debug(`${LOG_PREFIX_MDX_RENDERER} Writing temporary MDX module file:`, error);
-      await adapter.fs.writeFile(filePath, rewritten);
+      await localFs.writeTextFile(filePath, rewritten);
     }
     rendererLogger.info(`${LOG_PREFIX_MDX_RENDERER} Loading MDX module`, {
       filePath,
       codePreview: rewritten.substring(0, 300)
     });
+    setupSSRGlobals();
     const mod = await import(`file://${filePath}?v=${codeHash}`);
     const result = {
       ...mod,
@@ -5576,6 +9243,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 (error) {
     rendererLogger.error(`${LOG_PREFIX_MDX_RENDERER} MDX ESM load failed:`, error);
@@ -5634,7 +9305,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)
@@ -5733,7 +9404,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;
   }
@@ -5772,10 +9443,11 @@ var MDXRenderer = class {
       this.esmCacheDir = void 0;
     }
   }
-  async loadModuleESM(compiledProgramCode) {
+  async loadModuleESM(compiledProgramCode, adapter) {
     const context = {
       esmCacheDir: this.esmCacheDir,
-      moduleCache: this.moduleCache
+      moduleCache: this.moduleCache,
+      adapter
     };
     const result = await loadModuleESM(compiledProgramCode, context);
     this.esmCacheDir = context.esmCacheDir;
@@ -5952,15 +9624,61 @@ function AppWrapper({
 
 // src/react/components/Head.tsx
 init_deno_env();
-import React2 from "react";
+import React2, { useEffect, useRef as useRef3 } from "react";
+var isServer = typeof window === "undefined";
 function Head({ children }) {
+  const mountedRef = useRef3(false);
+  useEffect(() => {
+    mountedRef.current = true;
+    if (!children)
+      return;
+    const childArray = React2.Children.toArray(children);
+    const addedElements = [];
+    childArray.forEach((child) => {
+      if (!React2.isValidElement(child))
+        return;
+      const { type, props } = child;
+      if (typeof type !== "string")
+        return;
+      if (type === "body")
+        return;
+      if (type === "title") {
+        document.title = props.children || "";
+        return;
+      }
+      const element = document.createElement(type);
+      Object.entries(props).forEach(([key, value]) => {
+        if (key === "children")
+          return;
+        if (key === "className") {
+          element.setAttribute("class", String(value));
+        } else if (key === "htmlFor") {
+          element.setAttribute("for", String(value));
+        } else if (typeof value === "boolean") {
+          if (value)
+            element.setAttribute(key, "");
+        } else if (value != null) {
+          element.setAttribute(key, String(value));
+        }
+      });
+      if (props.children && typeof props.children === "string") {
+        element.textContent = props.children;
+      }
+      element.setAttribute("data-veryfront-managed", "1");
+      document.head.appendChild(element);
+      addedElements.push(element);
+    });
+    return () => {
+      addedElements.forEach((el) => el.remove());
+    };
+  }, [children]);
   return React2.createElement(
     "div",
     {
       "data-veryfront-head": "1",
       style: { display: "none" }
     },
-    children
+    isServer ? children : null
   );
 }