@vesk/vesk-cli 0.2.8 → 0.2.10

package/dist/cli.js

@@ -1605,8 +1605,11 @@ function buildRequestInit(options2) {
 }
 function resolveFetchUrl(url) {
   if (/^[a-z][a-z0-9+.-]*:/i.test(url) || url.startsWith("//")) return url;
-  const reqUrl = g().__vesk_request?.url;
-  const base = typeof reqUrl === "string" && /^https?:\/\//i.test(reqUrl) ? reqUrl : g().__vesk_ssr_base_url || "";
+  const ctx2 = g().__vesk_request;
+  const resolver = ctx2 && typeof ctx2.resolveUrl === "function" ? ctx2.resolveUrl : null;
+  if (resolver) return resolver(url);
+  const reqUrl = ctx2?.url;
+  const base = typeof reqUrl === "string" && /^https?:\/\//i.test(reqUrl) ? reqUrl : globalThis.__vesk_ssr_base_url || "";
   if (base) return new URL(url, base).href;
   return url;
 }
@@ -1666,7 +1669,34 @@ async function runFetcher(handle2, timeout) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve26) => setTimeout(resolve26, ms));
+  return new Promise((resolve27) => setTimeout(resolve27, ms));
+}
+function streamText(res, into, onChunk) {
+  const decoder = new TextDecoder();
+  let total = "";
+  const emit = (text) => {
+    if (!text) return;
+    total += text;
+    if (into) setInto(into, total);
+    if (onChunk) onChunk(text, total);
+  };
+  const body = res.body;
+  if (body && typeof body.getReader === "function") {
+    const reader = body.getReader();
+    return (async () => {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        emit(decoder.decode(value, { stream: true }));
+      }
+      emit(decoder.decode());
+      return total;
+    })();
+  }
+  return res.text().then((text) => {
+    emit(text);
+    return total;
+  });
 }
 function settle(handle2, data2) {
   if (handle2.block !== null && is_destroyed(handle2.block)) return;
@@ -1959,6 +1989,22 @@ var init_resource = __esm({
       ...options2,
       key: options2?.key ?? url
     });
+    useFetch.stream = (urlOrFn, options2) => {
+      const streamInto = options2?.into;
+      const streamOnChunk = options2?.onChunk;
+      const fetcher = (signal) => {
+        const url = typeof urlOrFn === "function" ? urlOrFn() : urlOrFn;
+        const init = buildRequestInit(options2 ?? {});
+        return doFetch(resolveFetchUrl(url), signal ? { ...init, signal } : init).then(async (res) => {
+          if (!res.ok) throw new HttpError(res.status, res.statusText);
+          return streamText(res, streamInto, streamOnChunk);
+        });
+      };
+      const key = options2?.key ?? (typeof urlOrFn === "string" ? urlOrFn : void 0);
+      const resource = useFetch(fetcher, { ...options2, key });
+      resource.into = streamInto;
+      return resource;
+    };
   }
 });
 
@@ -2032,10 +2078,10 @@ function createHydrateWalker(container, markerList) {
 }
 function hydrateViewport(container, componentFn, props, rootMargin = 500) {
   if (document.readyState !== "complete") {
-    return new Promise((resolve26) => {
+    return new Promise((resolve27) => {
       const onLoad = () => {
         window.removeEventListener("load", onLoad);
-        resolve26(hydrateViewport(container, componentFn, props, rootMargin));
+        resolve27(hydrateViewport(container, componentFn, props, rootMargin));
       };
       window.addEventListener("load", onLoad);
     });
@@ -2062,7 +2108,7 @@ function hydrateViewport(container, componentFn, props, rootMargin = 500) {
   const viewportWalker = createHydrateWalker(container, viewportMarkers);
   componentFn(props || {}, /* @__PURE__ */ new Map(), viewportWalker);
   if (deferredMarkers.length > 0) {
-    return new Promise((resolve26) => {
+    return new Promise((resolve27) => {
       const observer = new IntersectionObserver((entries) => {
         const toHydrate = [];
         for (const entry of entries) {
@@ -2085,7 +2131,7 @@ function hydrateViewport(container, componentFn, props, rootMargin = 500) {
         }
         if (observer._observed === 0) {
           observer.disconnect();
-          resolve26();
+          resolve27();
         }
       }, { rootMargin: `${rootMargin}px` });
       observer._observed = deferredMarkers.length;
@@ -2308,9 +2354,9 @@ function startProgress() {
   const step = () => {
     rafId = null;
     if (!animating || isServer2()) return;
-    const ts8 = now();
-    if (startTimeStamp === null) startTimeStamp = ts8;
-    const pct = globalOpts.estimatedProgress(globalOpts.duration, ts8 - startTimeStamp);
+    const ts9 = now();
+    if (startTimeStamp === null) startTimeStamp = ts9;
+    const pct = globalOpts.estimatedProgress(globalOpts.duration, ts9 - startTimeStamp);
     set(progressCell, Math.max(0, Math.min(100, pct)));
     rafId = setTimeout(step, 16);
   };
@@ -2948,12 +2994,12 @@ function ensureChunk(chunkUrl) {
   if (typeof document === "undefined" || typeof document.createElement !== "function") {
     return Promise.resolve();
   }
-  return new Promise((resolve26, reject) => {
+  return new Promise((resolve27, reject) => {
     const s = document.createElement("script");
     s.src = chunkUrl;
     s.onload = () => {
       failedChunks.delete(chunkUrl);
-      resolve26();
+      resolve27();
     };
     s.onerror = () => {
       loadedChunks.delete(chunkUrl);
@@ -15289,6 +15335,15 @@ function isIdentStartCode(code) {
 function isIdentCharCode(code) {
   return isIdentStartCode(code) || code >= 48 && code <= 57;
 }
+function getQualifiedJSXName2(object) {
+  if (!object) return object;
+  if (object.type === "JSXIdentifier") return object.name;
+  if (object.type === "JSXNamespacedName") return object.namespace.name + ":" + object.name.name;
+  if (object.type === "JSXMemberExpression") {
+    return getQualifiedJSXName2(object.object) + "." + getQualifiedJSXName2(object.property);
+  }
+  return null;
+}
 function looksLikeGenericArrowAt(input, pos) {
   let i = pos + 1;
   while (i < input.length && isWsChar(input.charCodeAt(i))) i++;
@@ -15372,6 +15427,9 @@ function VeskParserPlugin(config = {}) {
       #closeTagName = null;
       #jsxStartsStatement = false;
       #inTSTypeDecl = false;
+      #pendingChildStatement = false;
+      /** per-statement context-stack depths (LIFO — child statements may nest) */
+      #jsxChildDepthStack = [];
       constructor(options2, input) {
         super(options2, input);
       }
@@ -15379,7 +15437,231 @@ function VeskParserPlugin(config = {}) {
         const ctx2 = this.curContext();
         return ctx2 && (ctx2.token === "{" || ctx2.token === "function");
       }
+      #isJsxChildrenContext() {
+        const ctx2 = this.curContext();
+        return !!ctx2 && ctx2.token === "<tag>...</tag>";
+      }
+      /**
+       * Determines whether the text starting at `this.pos` opens a
+       * statement-mode control-flow header (`if (`, `for (`, `while (`,
+       * `switch (`, `try {`, `do {`) among JSX children. Scans chars only —
+       * the paren body must balance and be followed by a `{` block.
+       */
+      #scansChildStatement() {
+        const input = this.input;
+        let i = this.pos;
+        while (i < input.length && isWsChar(input.charCodeAt(i))) i++;
+        if (i >= input.length || !isIdentStartCode(input.charCodeAt(i))) return false;
+        const wordStart = i;
+        while (i < input.length && isIdentCharCode(input.charCodeAt(i))) i++;
+        const word = input.slice(wordStart, i);
+        if (word === "const" || word === "let" || word === "var") {
+          let depth2 = 0;
+          let seenAssign = false;
+          let q2 = i;
+          while (q2 < input.length) {
+            const c = input.charCodeAt(q2);
+            if (c === 34 || c === 39 || c === 96) {
+              const quote = c;
+              let tplDepth = 0;
+              q2++;
+              while (q2 < input.length) {
+                const ch = input.charCodeAt(q2);
+                if (ch === 92) {
+                  q2 += 2;
+                  continue;
+                }
+                if (quote === 96 && ch === 36 && input.charCodeAt(q2 + 1) === 123) {
+                  tplDepth++;
+                  q2 += 2;
+                  continue;
+                }
+                if (quote === 96 && ch === 125 && tplDepth > 0) {
+                  tplDepth--;
+                  q2++;
+                  continue;
+                }
+                if (ch === quote && tplDepth === 0) {
+                  q2++;
+                  break;
+                }
+                q2++;
+              }
+              continue;
+            }
+            if (c === 60 && input.charCodeAt(q2 + 1) === 47) return false;
+            if (c === 40 || c === 91 || c === 123) depth2++;
+            else if (c === 41 || c === 93 || c === 125) depth2--;
+            else if (c === 61 && depth2 === 0) {
+              const n2 = input.charCodeAt(q2 + 1);
+              const n1 = q2 > 0 ? input.charCodeAt(q2 - 1) : 0;
+              if (n2 !== 61 && n2 !== 62 && n1 !== 33 && n1 !== 60 && n1 !== 61) seenAssign = true;
+            } else if (c === 59 && depth2 === 0) return true;
+            else if ((c === 10 || c === 13) && depth2 === 0 && seenAssign) return true;
+            q2++;
+          }
+          return false;
+        }
+        if (isIdentStartCode(input.charCodeAt(wordStart))) {
+          let q2 = i;
+          while (q2 < input.length) {
+            const c = input.charCodeAt(q2);
+            if (c === 46) {
+              q2++;
+            } else if (c === 63 && input.charCodeAt(q2 + 1) === 46) {
+              q2 += 2;
+            } else break;
+            if (q2 >= input.length || !isIdentStartCode(input.charCodeAt(q2))) return false;
+            q2++;
+            while (q2 < input.length && isIdentCharCode(input.charCodeAt(q2))) q2++;
+          }
+          if (input.charCodeAt(q2) === 40) {
+            let depth2 = 0;
+            let callClosed = false;
+            let s = q2;
+            while (s < input.length) {
+              const c = input.charCodeAt(s);
+              if (c === 34 || c === 39 || c === 96) {
+                const quote = c;
+                let tplDepth = 0;
+                s++;
+                while (s < input.length) {
+                  const ch = input.charCodeAt(s);
+                  if (ch === 92) {
+                    s += 2;
+                    continue;
+                  }
+                  if (quote === 96 && ch === 36 && input.charCodeAt(s + 1) === 123) {
+                    tplDepth++;
+                    s += 2;
+                    continue;
+                  }
+                  if (quote === 96 && ch === 125 && tplDepth > 0) {
+                    tplDepth--;
+                    s++;
+                    continue;
+                  }
+                  if (ch === quote && tplDepth === 0) {
+                    s++;
+                    break;
+                  }
+                  s++;
+                }
+                continue;
+              }
+              if (c === 60 && input.charCodeAt(s + 1) === 47) return false;
+              if (c === 40 || c === 91 || c === 123) depth2++;
+              else if (c === 41 || c === 93 || c === 125) {
+                depth2--;
+                if (c === 41 && depth2 === 0) {
+                  callClosed = true;
+                  s++;
+                  break;
+                }
+              }
+              s++;
+            }
+            if (!callClosed) return false;
+            let d = 0;
+            for (; ; ) {
+              if (s >= input.length) return false;
+              const c = input.charCodeAt(s);
+              if (c === 60 && input.charCodeAt(s + 1) === 47) return false;
+              if (c === 34 || c === 39 || c === 96) {
+                const quote = c;
+                let tplDepth = 0;
+                s++;
+                while (s < input.length) {
+                  const ch = input.charCodeAt(s);
+                  if (ch === 92) {
+                    s += 2;
+                    continue;
+                  }
+                  if (quote === 96 && ch === 36 && input.charCodeAt(s + 1) === 123) {
+                    tplDepth++;
+                    s += 2;
+                    continue;
+                  }
+                  if (quote === 96 && ch === 125 && tplDepth > 0) {
+                    tplDepth--;
+                    s++;
+                    continue;
+                  }
+                  if (ch === quote && tplDepth === 0) {
+                    s++;
+                    break;
+                  }
+                  s++;
+                }
+                continue;
+              }
+              if (c === 40 || c === 91 || c === 123) d++;
+              else if (c === 41 || c === 93 || c === 125) d--;
+              else if (c === 59 && d === 0) return true;
+              else if ((c === 10 || c === 13) && d === 0) return true;
+              else if (c === 46) {
+                s++;
+                while (s < input.length && isIdentCharCode(input.charCodeAt(s))) s++;
+                continue;
+              } else if (isIdentCharCode(c) || isIdentStartCode(c)) return false;
+              s++;
+            }
+          }
+        }
+        if (word !== "if" && word !== "for" && word !== "while" && word !== "switch" && word !== "try" && word !== "do") return false;
+        let p = i;
+        while (p < input.length && isWsChar(input.charCodeAt(p))) p++;
+        if (word === "try" || word === "do") {
+          return input.charCodeAt(p) === 123;
+        }
+        if (input.charCodeAt(p) !== 40) return false;
+        let depth = 1;
+        let q = p + 1;
+        while (q < input.length) {
+          const c = input.charCodeAt(q);
+          if (c === 34 || c === 39 || c === 96) {
+            const quote = c;
+            q++;
+            while (q < input.length) {
+              const ch = input.charCodeAt(q);
+              if (ch === 92) {
+                q += 2;
+                continue;
+              }
+              if (ch === quote) {
+                q++;
+                break;
+              }
+              q++;
+            }
+            continue;
+          }
+          if (c === 40 || c === 91 || c === 123) depth++;
+          else if (c === 41 || c === 93 || c === 125) {
+            depth--;
+            if (c === 41 && depth === 0) break;
+          }
+          q++;
+        }
+        if (q >= input.length) return false;
+        let r = q + 1;
+        while (r < input.length && isWsChar(input.charCodeAt(r))) r++;
+        return input.charCodeAt(r) === 123;
+      }
       readToken(code) {
+        if (this.#componentDepth > 0 && this.#isJsxChildrenContext() && this.#scansChildStatement()) {
+          this.#pendingChildStatement = true;
+          this.#jsxChildDepthStack.push(this.context.length);
+          this.context.push(types.b_stat);
+          if (isWsChar(code)) {
+            this.skipSpace();
+            this.start = this.pos;
+            if (this.options.locations && typeof this.curPosition === "function") {
+              this.startLoc = this.curPosition();
+            }
+          }
+          return super.readToken(this.input.codePointAt(this.pos));
+        }
         if (this.#componentDepth > 0 && code === 60 && this.#isBlockContext()) {
           const next = this.input.charCodeAt(this.pos + 1);
           if (next === 47 || next >= 65 && next <= 90 || next >= 97 && next <= 122) {
@@ -15692,7 +15974,68 @@ function VeskParserPlugin(config = {}) {
         if (prefix.startsWith("<style") && isStyleBoundary(prefix.charCodeAt(6))) {
           return this.parseStyleElement(startPos, startLoc);
         }
-        return super.jsx_parseElementAt(startPos, startLoc);
+        return this.#parseElementWithStatements(startPos, startLoc);
+      }
+      /**
+       * Parses an entire JSX element (or fragment) starting after `<`,
+       * mirroring the vendored acorn-jsx `jsx_parseElementAt` with an added
+       * statement-mode branch: when `#pendingChildStatement` is set (a
+       * control-flow header like `if (…) {` appeared where JSX children
+       * expect text), a real statement is parsed into the children array.
+       */
+      #parseElementWithStatements(startPos, startLoc) {
+        const node = this.startNodeAt(startPos, startLoc);
+        const children = [];
+        const openingElement = this.jsx_parseOpeningElementAt(startPos, startLoc);
+        let closingElement = null;
+        if (!openingElement.selfClosing) {
+          contents: for (; ; ) {
+            if (this.#pendingChildStatement) {
+              this.#pendingChildStatement = false;
+              const stmt = this.parseStatement(null);
+              children.push(stmt);
+              this.context.length = this.#jsxChildDepthStack.pop() ?? this.context.length;
+              this.exprAllowed = true;
+              this.pos = this.start;
+              this.next();
+              continue;
+            }
+            switch (this.type) {
+              case tstt?.jsxTagStart:
+                startPos = this.start;
+                startLoc = this.startLoc;
+                this.next();
+                if (this.eat(tt.slash)) {
+                  closingElement = this.jsx_parseClosingElementAt(startPos, startLoc);
+                  break contents;
+                }
+                children.push(this.jsx_parseElementAt(startPos, startLoc));
+                break;
+              case tstt?.jsxText:
+                children.push(this.parseExprAtom());
+                break;
+              case tt.braceL:
+                children.push(this.jsx_parseExpressionContainer());
+                break;
+              default:
+                this.unexpected();
+            }
+          }
+          if (getQualifiedJSXName2(closingElement.name) !== getQualifiedJSXName2(openingElement.name)) {
+            this.raise(
+              closingElement.start,
+              "Expected corresponding JSX closing tag for <" + getQualifiedJSXName2(openingElement.name) + ">"
+            );
+          }
+        }
+        const fragmentOrElement = openingElement.name ? "Element" : "Fragment";
+        node["opening" + fragmentOrElement] = openingElement;
+        node["closing" + fragmentOrElement] = closingElement;
+        node.children = children;
+        if (this.type === tt.relational && this.value === "<") {
+          this.raise(this.start, "Adjacent JSX elements must be wrapped in an enclosing tag");
+        }
+        return this.finishNode(node, "JSX" + fragmentOrElement);
       }
       jsx_parseOpeningElementAt(startPos, startLoc) {
         const node = this.startNodeAt(startPos, startLoc);
@@ -16505,7 +16848,15 @@ function collectCalledIdentifiers(code) {
       const t = tokens[i];
       if (t.label !== "name") continue;
       const prev = i > 0 ? tokens[i - 1] : null;
-      if (prev && (prev.label === "." || prev.label === "?.")) continue;
+      if (prev && (prev.label === "." || prev.label === "?.")) {
+        const obj = i >= 2 ? tokens[i - 2] : null;
+        const next2 = tokens[i + 1];
+        if (obj && obj.label === "name" && next2) {
+          const nextCh2 = code[next2.start];
+          if (nextCh2 === "(" || nextCh2 === "<") result2.add(obj.value);
+        }
+        continue;
+      }
       const next = tokens[i + 1];
       if (!next) continue;
       const nextCh = code[next.start];
@@ -16593,6 +16944,7 @@ function importModuleTarget(importText) {
 function manualCollectCalledIdentifiers(code) {
   const result2 = /* @__PURE__ */ new Set();
   let i = 0;
+  let prevIdent = null;
   while (i < code.length) {
     const c = code[i];
     if (c === '"' || c === "'" || c === "`") {
@@ -16611,7 +16963,15 @@ function manualCollectCalledIdentifiers(code) {
         let k = skipWhitespace(code, j);
         if (code[k] === "<") k = skipTrackGeneric(code, k);
         if (code[k] === "(") result2.add(code.slice(i, j));
+      } else if (before === "." && prevIdent) {
+        let p = i - 1;
+        while (p > prevIdent[1] && (code[p] === "." || code[p] === "?" || code[p] === "\n" || code[p] === "	" || code[p] === " ")) p--;
+        if (p === prevIdent[1]) {
+          let k = skipWhitespace(code, j);
+          if (code[k] === "(") result2.add(code.slice(prevIdent[0], prevIdent[1]));
+        }
       }
+      prevIdent = [i, j];
       i = j;
       continue;
     }
@@ -16829,7 +17189,7 @@ function stripTypeImport(importSrc) {
   if (isTypeOnlyImport(stmt)) return null;
   const specs = stmt.specifiers || [];
   const kept = specs.filter((s) => s.importKind !== "type");
-  if (kept.length === 0) return null;
+  if (specs.length > 0 && kept.length === 0) return null;
   if (kept.length === specs.length) return importSrc;
   try {
     const rewritten = { ...stmt, specifiers: kept };
@@ -16846,6 +17206,505 @@ var init_vsk_imports = __esm({
   }
 });
 
+// ../compiler/src/module-imports.ts
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname as dirname2, extname, isAbsolute, join, resolve as resolve2 } from "node:path";
+import { print as print3 } from "esrap";
+import ts3 from "esrap/languages/ts";
+function cacheModule(p, val) {
+  MODULE_CACHE.delete(p);
+  MODULE_CACHE.set(p, val);
+  if (MODULE_CACHE.size > MAX_CACHE_ENTRIES) {
+    MODULE_CACHE.delete(MODULE_CACHE.keys().next().value);
+  }
+}
+function isCompilerOwnedTarget(target) {
+  if (target === "@vesk/runtime" || target === "@vesk/reactivity") return true;
+  for (const prefix of RUNTIME_PREFIXES) {
+    if (target.startsWith(prefix)) return true;
+  }
+  return false;
+}
+function isValueLessTarget(target) {
+  return target.endsWith(".vsk") || target.endsWith(".css") || target.endsWith(".md") || target.endsWith(".markdown");
+}
+function importBindingPairs(imp) {
+  const pairs = [];
+  let ast = null;
+  try {
+    ast = parse4(imp, { filename: "import.mjs" });
+  } catch {
+    ast = null;
+  }
+  if (!ast) return pairs;
+  const stmt = (ast.body || []).find((n) => n.type === "ImportDeclaration");
+  if (!stmt) return pairs;
+  const specifiers = stmt.specifiers || [];
+  for (const spec of specifiers) {
+    if (spec.importKind === "type") continue;
+    const local = spec.local?.name;
+    if (!local) continue;
+    if (spec.type === "ImportDefaultSpecifier") {
+      pairs.push({ local, imported: "default" });
+    } else if (spec.type === "ImportNamespaceSpecifier") {
+      pairs.push({ local, imported: "*" });
+    } else {
+      const importedSpec = spec.imported || spec.local;
+      const imported = importedSpec.name ?? importedSpec.value;
+      if (imported) pairs.push({ local, imported });
+    }
+  }
+  return pairs;
+}
+function localValueImportNames(importStrs) {
+  const names = [];
+  for (const imp of importStrs) {
+    const target = importModuleTarget(imp);
+    if (!target || isCompilerOwnedTarget(target) || isValueLessTarget(target)) continue;
+    for (const pair of importBindingPairs(imp)) names.push(pair.local);
+  }
+  return names;
+}
+function applyLocalModuleImports(__vesk, importStrs, sourcePath2) {
+  if (!sourcePath2) return;
+  const fromDir = dirname2(sourcePath2);
+  for (const imp of importStrs) {
+    const target = importModuleTarget(imp);
+    if (!target || isCompilerOwnedTarget(target) || isValueLessTarget(target)) continue;
+    const resolved = resolveSsrModule(target, fromDir);
+    if (!resolved) {
+      console.warn(`[vesk] SSR: cannot resolve "${target}" imported by ${sourcePath2} \u2014 the imported name will be undefined during server render.`);
+      continue;
+    }
+    const mod = loadSsrModule(resolved);
+    if (!mod || typeof mod !== "object") continue;
+    for (const pair of importBindingPairs(imp)) {
+      if (pair.imported === "*") {
+        __vesk[pair.local] = mod;
+      } else if (pair.imported in mod) {
+        __vesk[pair.local] = mod[pair.imported];
+      }
+    }
+  }
+}
+function nativeRequireFallback(absPath) {
+  try {
+    const req = createRequire(absPath);
+    const loaded = req(absPath);
+    if (loaded && typeof loaded === "object") return loaded;
+    if (loaded !== null && loaded !== void 0) return { default: loaded };
+    return null;
+  } catch {
+    return null;
+  }
+}
+function loadSsrModule(absPath) {
+  if (isBuiltinPath(absPath)) {
+    return loadBuiltin(absPath.slice(BUILTIN_PREFIX.length));
+  }
+  let mtimeMs = 0;
+  try {
+    mtimeMs = statSync(absPath).mtimeMs;
+  } catch {
+    return null;
+  }
+  const inFlight = EVALUATING.get(absPath);
+  if (inFlight !== void 0) return inFlight;
+  const cachedVal = MODULE_CACHE.get(absPath);
+  if (cachedVal && cachedVal.mtimeMs === mtimeMs && depsFresh(cachedVal)) return cachedVal.exports;
+  const frame = /* @__PURE__ */ new Set();
+  depStack.push(frame);
+  try {
+    let exportsObj = null;
+    if (absPath.endsWith(".json")) {
+      try {
+        exportsObj = JSON.parse(readFileSync(absPath, "utf-8"));
+        if (exportsObj && typeof exportsObj === "object" && !("default" in exportsObj)) {
+          exportsObj.default = exportsObj;
+        }
+      } catch {
+        exportsObj = null;
+      }
+    } else {
+      exportsObj = {};
+      EVALUATING.set(absPath, exportsObj);
+      const ran = evaluateModuleFile(absPath, exportsObj);
+      if (!ran) exportsObj = null;
+    }
+    if (exportsObj === null) {
+      exportsObj = nativeRequireFallback(absPath);
+    }
+    if (exportsObj === null) return null;
+    cacheModule(absPath, { mtimeMs, deps: captureClosure(frame), exports: exportsObj });
+    return exportsObj;
+  } finally {
+    depStack.pop();
+    EVALUATING.delete(absPath);
+  }
+}
+function captureClosure(frame) {
+  const deps = [];
+  for (const dep of frame) {
+    try {
+      deps.push({ path: dep, mtimeMs: statSync(dep).mtimeMs });
+    } catch {
+      deps.push({ path: dep, mtimeMs: -1 });
+    }
+  }
+  return deps;
+}
+function depsFresh(cachedVal) {
+  for (const dep of cachedVal.deps) {
+    try {
+      if (statSync(dep.path).mtimeMs !== dep.mtimeMs) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function evaluateModuleFile(absPath, exportsObj) {
+  let raw2;
+  try {
+    raw2 = readFileSync(absPath, "utf-8");
+  } catch (err) {
+    console.warn(`[vesk] SSR: failed to read ${absPath}: ${err?.message ?? String(err)}`);
+    return false;
+  }
+  let ast = null;
+  try {
+    ast = parse4(raw2, { filename: absPath });
+  } catch {
+    ast = null;
+  }
+  if (!ast) {
+    try {
+      const fn = new Function("require", "module", "exports", "__dirname", "__filename", raw2);
+      fn(createModuleRequire(dirname2(absPath)), { exports: exportsObj }, exportsObj, dirname2(absPath), absPath);
+    } catch (err) {
+      console.warn(`[vesk] SSR: failed to load ${absPath}: ${err?.message ?? String(err)}`);
+      return false;
+    }
+    return true;
+  }
+  const unsupported = findUnsupportedEsm(ast.body);
+  if (unsupported) {
+    throw new Error(
+      `${absPath} uses ${unsupported} \u2014 not representable in the SSR module loader. Split it out of the module or avoid ${unsupported} in .vsk-imported code.`
+    );
+  }
+  let stripped = ast;
+  if (hasTsSyntax(ast)) stripped = stripTsTypes(ast);
+  stripped.body = (stripped.body || []).filter((n) => {
+    if (!n) return false;
+    return !isTypeOnlyStatement(n);
+  });
+  const body = esmToCjs(stripped.body);
+  try {
+    const fn = new Function("require", "module", "exports", "__dirname", "__filename", "'use strict';\n" + body);
+    fn(createModuleRequire(dirname2(absPath)), { exports: exportsObj }, exportsObj, dirname2(absPath), absPath);
+  } catch (err) {
+    console.warn(`[vesk] SSR: failed to load ${absPath}: ${err?.message ?? String(err)}`);
+    return false;
+  }
+  return true;
+}
+function findUnsupportedEsm(body) {
+  for (const stmt of body) {
+    const hit = scanUnsupportedNode(stmt);
+    if (hit) return hit;
+  }
+  return null;
+}
+function scanUnsupportedNode(node, inFunction = false) {
+  if (!node || typeof node !== "object") return null;
+  const n = node;
+  const t = n.type;
+  if (t === "MetaProperty" || t === "MetaProperty" && n.meta?.name === "import") {
+    return "import.meta";
+  }
+  if (!inFunction && t === "AwaitExpression") return "top-level await";
+  if (t === "FunctionDeclaration" || t === "FunctionExpression" || t === "ArrowFunctionExpression" || t === "ClassDeclaration" || t === "ClassExpression") {
+    return null;
+  }
+  for (const key of Object.keys(n)) {
+    const val = n[key];
+    if (Array.isArray(val)) {
+      for (const item of val) {
+        if (item && typeof item === "object") {
+          const sub = scanUnsupportedNode(item, inFunction);
+          if (sub) return sub;
+        }
+      }
+    } else if (val && typeof val === "object") {
+      const sub = scanUnsupportedNode(val, inFunction);
+      if (sub) return sub;
+    }
+  }
+  return null;
+}
+function createModuleRequire(fromDir) {
+  return (specifier) => {
+    const resolved = resolveSsrModule(specifier, fromDir);
+    if (!resolved) throw new Error(`Cannot find module '${specifier}'`);
+    for (const frame of depStack) frame.add(resolved);
+    const loaded = loadSsrModule(resolved);
+    if (loaded === null) throw new Error(`Cannot load module '${specifier}'`);
+    return loaded;
+  };
+}
+function resolveSsrModule(specifier, fromDir) {
+  let resolved = null;
+  if (specifier === "." || specifier === ".." || isAbsolute(specifier)) {
+    resolved = probeFile(resolve2(specifier));
+  } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    resolved = probeFile(resolve2(fromDir, specifier));
+  } else {
+    const native = nativeResolve(specifier, fromDir);
+    if (native) return native;
+    let dir = fromDir;
+    for (let depth = 0; depth < 64; depth++) {
+      const base = join(dir, "node_modules", specifier);
+      const found = probeFile(base);
+      if (found) {
+        resolved = found;
+        break;
+      }
+      const parent = dirname2(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return resolved ? toRealPath(resolved) : null;
+}
+function toRealPath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function nativeResolve(specifier, fromDir) {
+  try {
+    const req = createRequire(join(fromDir, "__vesk_resolve__.js"));
+    const resolved = req.resolve(specifier);
+    if (isAbsolute(resolved)) return toRealPath(resolved);
+    return builtinMarker(resolved);
+  } catch {
+    return null;
+  }
+}
+function builtinMarker(name) {
+  return BUILTIN_PREFIX + name;
+}
+function isBuiltinPath(p) {
+  return p.startsWith(BUILTIN_PREFIX);
+}
+function loadBuiltin(name) {
+  const id = name.startsWith("node:") ? name : `node:${name}`;
+  const cachedVal = BUILTIN_CACHE.get(id);
+  if (cachedVal) return cachedVal;
+  try {
+    const req = createRequire(join("/", "__vesk_builtin__.js"));
+    const loaded = req(id);
+    let mod = null;
+    if (loaded && typeof loaded === "object") mod = loaded;
+    else if (loaded !== null && loaded !== void 0) mod = { default: loaded };
+    if (mod) BUILTIN_CACHE.set(id, mod);
+    return mod;
+  } catch {
+    return null;
+  }
+}
+function statOrNull(p) {
+  try {
+    return statSync(p);
+  } catch {
+    return null;
+  }
+}
+function probeFile(base) {
+  const st = statOrNull(base);
+  if (st && st.isFile()) return base;
+  if (st && st.isDirectory()) {
+    const pkgPath = join(base, "package.json");
+    const pkgSt = statOrNull(pkgPath);
+    if (pkgSt && pkgSt.isFile()) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (typeof pkg.main === "string" && pkg.main.length > 0) {
+          const viaMain = probeFile(resolve2(base, pkg.main));
+          if (viaMain) return viaMain;
+        }
+      } catch {
+      }
+    }
+    return probeFile(join(base, "index"));
+  }
+  const ext = extname(base);
+  if (ext.length === 0 || "/\\".includes(base[base.length - 1])) {
+    for (const suffix of EXTENSIONS) {
+      const candidate = base + suffix;
+      const cst = statOrNull(candidate);
+      if (cst && cst.isFile()) return candidate;
+    }
+  }
+  return null;
+}
+function astName(node) {
+  if (!node) return "undefined";
+  if (node.type === "Identifier" && typeof node.name === "string") return node.name;
+  return printNode(node);
+}
+function printNode(node) {
+  try {
+    return print3(node, ts3()).code.trim();
+  } catch {
+    return "";
+  }
+}
+function memberAccess(obj, prop) {
+  if (prop.type === "Identifier" && typeof prop.name === "string") return `${obj}.${prop.name}`;
+  if ((prop.type === "Literal" || prop.type === "StringLiteral") && typeof prop.value === "string") {
+    return `${obj}[${JSON.stringify(prop.value)}]`;
+  }
+  return `${obj}[${astName(prop)}]`;
+}
+function exportKeyName(node) {
+  if (!node) return "";
+  if (node.type === "Identifier" && typeof node.name === "string") return node.name;
+  if ((node.type === "Literal" || node.type === "StringLiteral") && typeof node.value === "string") return node.value;
+  const printed = printNode(node);
+  return stripOuterQuotes(printed);
+}
+function stripOuterQuotes(s) {
+  if (s.length >= 2) {
+    const first = s[0];
+    const last = s[s.length - 1];
+    if ((first === '"' || first === "'" || first === "`") && first === last) return s.slice(1, -1);
+  }
+  return s;
+}
+function exportGetter(lines, key, valueExpr) {
+  lines.push(`Object.defineProperty(exports, ${JSON.stringify(key)}, { get: () => ${valueExpr}, enumerable: true });`);
+}
+function esmToCjs(body) {
+  const lines = [];
+  for (const stmt of body) {
+    switch (stmt.type) {
+      case "ImportDeclaration": {
+        const source = printNode(stmt.source);
+        const specifiers = stmt.specifiers || [];
+        if (specifiers.length === 0) {
+          lines.push(`require(${source});`);
+          continue;
+        }
+        for (const spec of specifiers) {
+          if (spec.type === "ImportNamespaceSpecifier") {
+            lines.push(`const ${astName(spec.local)} = require(${source});`);
+          } else if (spec.type === "ImportDefaultSpecifier") {
+            lines.push(`const ${astName(spec.local)} = require(${source}).default;`);
+          } else {
+            const local = astName(spec.local);
+            const imported = spec.imported;
+            if (imported && spec.importKind === "type") continue;
+            lines.push(`const ${local} = ${memberAccess(`require(${source})`, imported || spec.local)};`);
+          }
+        }
+        break;
+      }
+      case "ExportNamedDeclaration": {
+        if (stmt.exportKind === "type") continue;
+        const declaration = stmt.declaration;
+        const source = stmt.source ? printNode(stmt.source) : null;
+        if (declaration) {
+          const printed = printNode(declaration);
+          if (printed) {
+            lines.push(printed);
+            if (declaration.type === "VariableDeclaration") {
+              const declarators = declaration.declarations || [];
+              for (const d of declarators) {
+                if (d.id && d.id.type === "Identifier") exportGetter(lines, exportKeyName(d.id), d.id.name ?? "");
+              }
+            } else if (declaration.id) {
+              const name = declaration.id;
+              exportGetter(lines, exportKeyName(name), name.name ?? "");
+            }
+          }
+        } else if (source) {
+          const modVar = `__veskExport${exportCounter++}`;
+          lines.push(`const ${modVar} = require(${source});`);
+          const specifiers = stmt.specifiers || [];
+          for (const spec of specifiers) {
+            if (spec.exportKind === "type") continue;
+            const local = spec.local;
+            const exported = spec.exported;
+            exportGetter(lines, exportKeyName(exported), memberAccess(modVar, local));
+          }
+        } else {
+          const specifiers = stmt.specifiers || [];
+          for (const spec of specifiers) {
+            if (spec.exportKind === "type") continue;
+            const local = spec.local;
+            const exported = spec.exported;
+            exportGetter(lines, exportKeyName(exported), astName(local));
+          }
+        }
+        break;
+      }
+      case "ExportDefaultDeclaration": {
+        const declaration = stmt.declaration;
+        if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
+          if (declaration.id) {
+            const name = declaration.id.name;
+            lines.push(printNode(declaration));
+            lines.push(`exports.default = ${name};`);
+          } else {
+            const expr = { ...declaration, type: declaration.type === "FunctionDeclaration" ? "FunctionExpression" : "ClassExpression" };
+            lines.push(`exports.default = ${printNode(expr)};`);
+          }
+        } else {
+          lines.push(`exports.default = ${printNode(declaration)};`);
+        }
+        break;
+      }
+      case "ExportAllDeclaration": {
+        const source = printNode(stmt.source);
+        const modVar = `__veskExport${exportCounter++}`;
+        lines.push(`const ${modVar} = require(${source});`);
+        if (stmt.exported) {
+          lines.push(`exports[${JSON.stringify(exportKeyName(stmt.exported))}] = ${modVar};`);
+        } else {
+          lines.push(`for (const __veskKey in ${modVar}) { if (__veskKey !== 'default' && __veskKey !== '__esModule' && !(__veskKey in exports)) exports[__veskKey] = ${modVar}[__veskKey]; }`);
+        }
+        break;
+      }
+      default:
+        lines.push(printNode(stmt));
+    }
+  }
+  return lines.join("\n");
+}
+var RUNTIME_PREFIXES, EXTENSIONS, BUILTIN_PREFIX, BUILTIN_CACHE, MODULE_CACHE, MAX_CACHE_ENTRIES, depStack, EVALUATING, exportCounter;
+var init_module_imports = __esm({
+  "../compiler/src/module-imports.ts"() {
+    "use strict";
+    init_parser();
+    init_strip_ts();
+    init_tokens();
+    RUNTIME_PREFIXES = ["@vesk/runtime/", "@vesk/reactivity/", "@vesk/types", "@vesk/"];
+    EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".jsx", ".json"];
+    BUILTIN_PREFIX = "\0builtin:";
+    BUILTIN_CACHE = /* @__PURE__ */ new Map();
+    MODULE_CACHE = /* @__PURE__ */ new Map();
+    MAX_CACHE_ENTRIES = 256;
+    depStack = [];
+    EVALUATING = /* @__PURE__ */ new Map();
+    exportCounter = 0;
+  }
+});
+
 // ../compiler/src/ir-generator.ts
 function parseExprNode(text) {
   try {
@@ -16918,9 +17777,9 @@ function componentUsesFetch(nodes) {
     if (node instanceof ServerBlock || node instanceof ClientBlock) {
       if (componentUsesFetch(node.children)) return true;
     } else if (node instanceof RuntimeStatement) {
-      if (node.raw.includes("useFetch(")) return true;
+      if (node.raw.includes("useFetch(") || node.raw.includes("useFetch.")) return true;
     } else if (node instanceof DynamicBinding) {
-      if (node.expression.raw.includes("useFetch(")) return true;
+      if (node.expression.raw.includes("useFetch(") || node.expression.raw.includes("useFetch.")) return true;
     } else if (node instanceof MapRegion) {
       if (componentUsesFetch(node.bodyTemplate)) return true;
       if (componentUsesFetch(node.alternateNodes)) return true;
@@ -17212,6 +18071,21 @@ function processJSXChildren(source, children) {
     } else if (child.type === "JSXFragment") {
       for (const c of child.children) result2.push(...processJSXChildren(source, [c]));
       i++;
+    } else if (child.type === "ForOfStatement") {
+      let alternate = [];
+      let consumed = 1;
+      const emptyText = children[i + 1];
+      const emptyContainer = children[i + 2];
+      if (emptyText && emptyText.type === "JSXText" && ["#empty", "empty"].includes(emptyText.value.trim()) && emptyContainer && emptyContainer.type === "JSXExpressionContainer" && emptyContainer.expression.type !== "JSXEmptyExpression") {
+        alternate = exprToIR(source, emptyContainer.expression);
+        consumed = 3;
+      }
+      result2.push(...processForStatement(source, child, alternate));
+      i += consumed;
+      continue;
+    } else if (child.type === "IfStatement" || child.type === "ForStatement" || child.type === "ForInStatement" || child.type === "WhileStatement" || child.type === "DoWhileStatement" || child.type === "SwitchStatement" || child.type === "TryStatement" || child.type === "VariableDeclaration" || child.type === "ExpressionStatement" || child.type === "ReturnStatement" || child.type === "WithStatement" || child.type === "LabeledStatement") {
+      result2.push(...processStatementModeBody(source, [child]));
+      i++;
     } else {
       i++;
     }
@@ -17248,6 +18122,19 @@ function exprToIR(source, expr) {
   }
   return [new DynamicBinding(toExpression(source, expr))];
 }
+function isRenderableExpression(expr) {
+  const t = expr.type;
+  if (t === "CallExpression" || t === "NewExpression" || t === "AssignmentExpression" || t === "UpdateExpression" || t === "AwaitExpression" || t === "YieldExpression" || t === "TaggedTemplateExpression" || t === "ImportExpression" || t === "MetaProperty") {
+    return false;
+  }
+  if (t === "UnaryExpression") {
+    return expr.operator !== "delete" && expr.operator !== "void";
+  }
+  if (t === "SequenceExpression") {
+    return isRenderableExpression(expr.expressions[expr.expressions.length - 1]);
+  }
+  return true;
+}
 function processJSXCallbackBody(source, body) {
   if (body.type === "JSXElement") return processJSXElement(source, body);
   if (body.type === "JSXFragment") {
@@ -17332,11 +18219,14 @@ function buildGuardChain(source, guardClauses, mainReturn) {
     const guard = guardClauses[i];
     const condExpr = toExpression(source, guard.test);
     const consequent = [];
-    if (guard.consequent.type === "ReturnStatement" && guard.consequent.argument) {
-      if (guard.consequent.argument.type === "JSXElement") {
-        consequent.push(...processJSXElement(source, guard.consequent.argument));
+    const guardReturn = getReturnArgument(guard.consequent);
+    if (guardReturn) {
+      if (guardReturn.type === "JSXElement") {
+        consequent.push(...processJSXElement(source, guardReturn));
+      } else if (guardReturn.type === "JSXFragment") {
+        for (const c of guardReturn.children) consequent.push(...processJSXChildren(source, [c]));
       } else {
-        consequent.push(new DynamicBinding(toExpression(source, guard.consequent.argument)));
+        consequent.push(new DynamicBinding(toExpression(source, guardReturn)));
       }
     }
     currentAlternate = [new OpaqueDynamicRegion(condExpr, consequent, currentAlternate)];
@@ -17367,7 +18257,14 @@ function hasJSXInSubtree(node) {
   return false;
 }
 function isGuardClause(node) {
-  return node.type === "IfStatement" && node.consequent.type === "ReturnStatement" && hasJSXInSubtree(node.consequent);
+  return node.type === "IfStatement" && !node.alternate && getReturnArgument(node.consequent) !== null && hasJSXInSubtree(node.consequent);
+}
+function getReturnArgument(node) {
+  if (node.type === "ReturnStatement") return node.argument ?? null;
+  if (node.type === "BlockStatement" && node.body.length === 1 && node.body[0].type === "ReturnStatement") {
+    return node.body[0].argument ?? null;
+  }
+  return null;
 }
 function isStatementMode(bodyStmts) {
   if (bodyStmts.some((s) => s.type === "JSXElement" || s.type === "JSXExpressionContainer" || s.type === "JSXFragment")) return true;
@@ -17518,6 +18415,13 @@ function processStatementModeBody(source, bodyStmts) {
       nodes.push(...processForStatement(source, stmt));
     } else if (stmt.type === "ForStatement") {
       nodes.push(...processForStatement(source, stmt));
+    } else if (stmt.type === "ExpressionStatement") {
+      if (isRenderableExpression(stmt.expression)) {
+        nodes.push(...exprToIR(source, stmt.expression));
+      } else {
+        const raw2 = getSource(source, stmt);
+        if (raw2) nodes.push(new RuntimeStatement(raw2, stmt, source));
+      }
     } else if (stmt.type === "ClassDeclaration") {
       throw VeskError.classDecl();
     } else {
@@ -17823,7 +18727,11 @@ function generateIR(ast, source) {
       if (importModuleTarget(imp) !== "@vesk/runtime") continue;
       for (const n of extractImportNames(imp)) existing.add(n);
     }
-    const missing = [...usedFunctions].filter((f) => !existing.has(f));
+    const boundLocally = /* @__PURE__ */ new Set();
+    for (const imp of imports) {
+      for (const pair of importBindingPairs(imp)) boundLocally.add(pair.local);
+    }
+    const missing = [...usedFunctions].filter((f) => !existing.has(f) && !boundLocally.has(f));
     if (missing.length > 0) {
       imports.push(`import { ${missing.join(", ")} } from '@vesk/runtime';`);
     }
@@ -17840,6 +18748,7 @@ var init_ir_generator = __esm({
     init_scan();
     init_strip_ts();
     init_vsk_imports();
+    init_module_imports();
     init_tokens();
     __vskAnnotations = [];
   }
@@ -19342,7 +20251,7 @@ var init_request = __esm({
         });
       }
     };
-    VeskRequest = class extends ServerRequest {
+    VeskRequest = class _VeskRequest extends ServerRequest {
       _query;
       _ip;
       _protocol;
@@ -19360,6 +20269,21 @@ var init_request = __esm({
         this._body = null;
         this._bodyPromise = null;
         this._parsedUrl = null;
+        const cookieHeader = this.headers?.get("cookie") || "";
+        if (cookieHeader) {
+          for (const part of cookieHeader.split(";")) {
+            const eq = part.indexOf("=");
+            if (eq > 0) {
+              const name = part.slice(0, eq).trim();
+              const val = part.slice(eq + 1).trim();
+              try {
+                this._cookies[name] = decodeURIComponent(val);
+              } catch {
+                this._cookies[name] = val;
+              }
+            }
+          }
+        }
         Object.defineProperty(this, "body", {
           get: () => {
             if (!this._bodyPromise) {
@@ -19371,6 +20295,52 @@ var init_request = __esm({
           enumerable: true
         });
       }
+      /**
+       * The request's host header (honoring `x-forwarded-host` when
+       * setTrustProxy() is enabled). Falls back to the parsed URL host.
+       */
+      get host() {
+        const trust = this._security.trustProxy === true;
+        const fwd = trust ? this.headers?.get("x-forwarded-host") : void 0;
+        const header = typeof fwd === "string" && fwd ? fwd : this.headers?.get("host") || "";
+        if (header) return header;
+        return this.parsedUrl.host || "localhost";
+      }
+      /** Absolute origin (`protocol://host`) — the base for resolving relative URLs. */
+      get origin() {
+        return `${this.protocol}://${this.host}`;
+      }
+      /**
+       * Resolves a possibly-relative URL against this request's own origin.
+       * Absolute URLs (scheme or protocol-relative `//`) pass through untouched.
+       * Used by the runtime SSR fetcher (`resolveFetchUrl`) to make in-app
+       * fetches (e.g. `/api/...`) work during server rendering.
+       */
+      resolveUrl(url) {
+        if (/^[a-z][a-z0-9+.-]*:/i.test(url) || url.startsWith("//")) return url;
+        return new URL(url, this.origin).href;
+      }
+      /** locals map accessors so <VeskRequest> can double as the middleware ctx. */
+      set(key, value) {
+        this._locals[key] = value;
+      }
+      get(key) {
+        return this._locals[key];
+      }
+      /**
+       * Wraps an inbound platform `Request` (from dev/prod/platform handlers)
+       * into a VeskRequest carrying the same method, headers and cookie store.
+       * Params/locals can be seeded so useParams()/useRequest() work in renders.
+       */
+      static from(request, init) {
+        const vreq = new _VeskRequest(request instanceof Request ? request.url : String(request), {
+          method: request.method,
+          headers: request.headers
+        });
+        if (init?.params) vreq._params = { ...init.params };
+        if (init?.locals) vreq._locals = { ...init.locals };
+        return vreq;
+      }
       get parsedUrl() {
         if (!this._parsedUrl) {
           this._parsedUrl = new URL(this.url);
@@ -19574,6 +20544,10 @@ var init_request = __esm({
           headers: { "Content-Type": "text/html; charset=utf-8", ...init?.headers }
         });
       }
+      /** Chunked streaming response over a `ReadableStream` body (SSE, file streams, …). */
+      static stream(readable, init) {
+        return new __VeskResponse(readable, init);
+      }
     };
     VeskResponse = new Proxy(_VeskResponse, {
       apply(target, _thisArg, args2) {
@@ -21940,6 +22914,84 @@ function wireCopyHandlers(root3) {
 function mdIsSSR() {
   return typeof document === "undefined";
 }
+function stringEndsWith(s, suffix) {
+  if (suffix.length > s.length) return false;
+  for (let i = 0; i < suffix.length; i++) {
+    if (s[s.length - suffix.length + i] !== suffix[i]) return false;
+  }
+  return true;
+}
+function isPublicMarkdownPath(v) {
+  if (typeof v !== "string") return false;
+  const s = v;
+  if (s.length < 2 || s.charCodeAt(0) !== 47) return false;
+  if (s.charCodeAt(1) === 47) return false;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 63 || c === 35 || c === 92) return false;
+  }
+  const lower = s.toLowerCase();
+  return stringEndsWith(lower, ".md") || stringEndsWith(lower, ".markdown");
+}
+function getMdPathCell(path) {
+  let cell = mdPathCells.get(path);
+  if (!cell) {
+    cell = tracked(void 0);
+    mdPathCells.set(path, cell);
+  }
+  return cell;
+}
+function ensureMdPathLoaded(path) {
+  if (mdPathCache.has(path) || mdPathInflight.has(path)) return;
+  const ssr = getSsrData("md:" + path);
+  if (typeof ssr === "string") {
+    mdPathCache.set(path, ssr);
+    return;
+  }
+  mdPathInflight.add(path);
+  fetch(path).then((r) => r.ok ? r.text() : Promise.reject(r)).then((text) => {
+    mdPathCache.set(path, text);
+    set(getMdPathCell(path), text);
+  }).catch(() => {
+    mdPathCache.set(path, null);
+    set(getMdPathCell(path), null);
+  }).finally(() => {
+    mdPathInflight.delete(path);
+  });
+}
+function readServerMdPath(path) {
+  const hook = globalThis.__vsk_md_read_file;
+  if (typeof hook !== "function") return null;
+  try {
+    const out = hook(path);
+    if (typeof out === "string") return out;
+  } catch {
+  }
+  return null;
+}
+function resolveMdSource(value) {
+  const s = String(value ?? "");
+  if (!isPublicMarkdownPath(s)) return s;
+  if (mdIsSSR()) {
+    const content = readServerMdPath(s);
+    if (content !== null) {
+      setSsrData("md:" + s, content);
+      return content;
+    }
+    return s;
+  }
+  ensureMdPathLoaded(s);
+  const cached = mdPathCache.get(s);
+  return cached === void 0 || cached === null ? s : cached;
+}
+function streamCellFrom(rawContent) {
+  if (rawContent === null || typeof rawContent !== "object") return null;
+  const into = rawContent.into;
+  if (into !== null && typeof into === "object" && typeof into.get === "function") {
+    return into;
+  }
+  return null;
+}
 function buildHtml(content, props) {
   const global = getMdPolicy();
   const mode = props.html || global.html;
@@ -21976,8 +23028,10 @@ function buildHtml(content, props) {
 }
 function Md(props, _registry, hydrate) {
   const rawContent = props.content;
-  const content = String(unwrapMaybeCell(rawContent) ?? "");
-  const html = buildHtml(content, props);
+  const streamTarget = streamCellFrom(rawContent);
+  const contentCell = streamTarget ?? rawContent;
+  const content = String(unwrapMaybeCell(contentCell) ?? "");
+  const html = buildHtml(resolveMdSource(content), props);
   const classNameRaw = props.className != null ? String(props.className) : props.class != null ? String(props.class) : "";
   const themeClass = props.theme === "dark" ? " vesk-md-dark" : "";
   const className = `vesk-md${themeClass}${classNameRaw ? " " + classNameRaw : ""}`;
@@ -21988,7 +23042,8 @@ function Md(props, _registry, hydrate) {
   const propFg = safeColorValue(String(props.codeFg ?? ""));
   if (propFg && propFg !== "none") wrapperParts.push(`--md-code-fg:${propFg}`);
   const wrapperStyle = wrapperParts.length > 0 ? escapeHtml3(wrapperParts.join(";")) : "";
-  const reactive = isCell(rawContent);
+  const reactive = isCell(contentCell);
+  const pathMode = isPublicMarkdownPath(content);
   if (mdIsSSR()) {
     const attrs = className ? ` class="${escapeHtml3(className)}"` : "";
     const styleAttr = style || wrapperStyle ? ` style="${[wrapperStyle, style.split('"').join("&quot;")].filter(Boolean).join(";")}"` : "";
@@ -22000,11 +23055,19 @@ function Md(props, _registry, hydrate) {
       const existing = hydrate.root.querySelector("div");
       if (existing) el = existing;
     }
-    el.innerHTML = html;
+    const claimed = !!el.parentNode;
+    if (pathMode && claimed) {
+      el.setAttribute("data-vsk-md-ssr", "1");
+      if (mdPathCache.has(content)) el.innerHTML = html;
+    } else {
+      el.innerHTML = html;
+    }
     el.className = className;
     el.style.cssText = [wrapperStyle, style].filter(Boolean).join(";");
     wireCopyHandlers(el);
-    if (reactive) subscribeContent(el, rawContent, props);
+    if (reactive || pathMode) {
+      subscribeContent(el, contentCell, props, pathMode && claimed ? { trustInitialSsr: true, initialValue: content } : void 0);
+    }
     if (el.parentNode) return document.createDocumentFragment();
     return el;
   }
@@ -22013,21 +23076,41 @@ function Md(props, _registry, hydrate) {
   div.className = className;
   div.style.cssText = [wrapperStyle, style].filter(Boolean).join(";");
   wireCopyHandlers(div);
-  if (reactive) subscribeContent(div, rawContent, props);
+  if (reactive || pathMode) subscribeContent(div, contentCell, props);
   return div;
 }
-function subscribeContent(el, rawContent, props) {
+function subscribeContent(el, rawContent, props, opts) {
+  const trust = opts?.trustInitialSsr === true;
+  const initial = opts?.initialValue;
+  let ran = false;
   effect(() => {
     const value = String(unwrapMaybeCell(rawContent) ?? "");
-    el.innerHTML = buildHtml(value, props);
+    if (isPublicMarkdownPath(value)) {
+      const known = getSsrData("md:" + value) !== void 0 || mdPathCache.has(value);
+      ensureMdPathLoaded(value);
+      const cell = getMdPathCell(value);
+      get(cell);
+      if (trust && !ran && value === initial && !known) {
+        ran = true;
+        return;
+      }
+      ran = true;
+      el.innerHTML = buildHtml(resolveMdSource(value), props);
+      wireCopyHandlers(el);
+      return;
+    }
+    ran = true;
+    el.innerHTML = buildHtml(resolveMdSource(value), props);
     wireCopyHandlers(el);
   });
 }
-var COLOR_FUNCS, SAFE_SCHEMES, KW_JS, KW_VSK, LIT_JS, KW_PY, LIT_PY, KW_GO, LIT_GO, KW_RUST, LIT_RUST, KW_SQL, KW_BASH, NAMED_ENTITIES, URL_ATTRS, MD_DEFAULT_ALLOW_TAGS, MD_BASE_CSS, __globalMode, __globalAllowTags, __sessionWarnings, __warnedKeys, __suppressMdConsoleWarnings;
+var COLOR_FUNCS, SAFE_SCHEMES, KW_JS, KW_VSK, LIT_JS, KW_PY, LIT_PY, KW_GO, LIT_GO, KW_RUST, LIT_RUST, KW_SQL, KW_BASH, NAMED_ENTITIES, URL_ATTRS, MD_DEFAULT_ALLOW_TAGS, MD_BASE_CSS, __globalMode, __globalAllowTags, __sessionWarnings, __warnedKeys, __suppressMdConsoleWarnings, mdPathCache, mdPathCells, mdPathInflight;
 var init_md = __esm({
   "../runtime/src/md.ts"() {
     "use strict";
     init_ripple_blocks();
+    init_ripple_runtime();
+    init_resource();
     COLOR_FUNCS = /* @__PURE__ */ new Set(["rgb", "rgba", "hsl", "hsla", "hwb", "lab", "lch", "oklab", "oklch", "color", "color-mix"]);
     SAFE_SCHEMES = ["http:", "https:", "mailto:", "tel:"];
     KW_JS = /* @__PURE__ */ new Set([
@@ -22429,6 +23512,9 @@ var init_md = __esm({
     __sessionWarnings = [];
     __warnedKeys = /* @__PURE__ */ new Set();
     __suppressMdConsoleWarnings = false;
+    mdPathCache = /* @__PURE__ */ new Map();
+    mdPathCells = /* @__PURE__ */ new Map();
+    mdPathInflight = /* @__PURE__ */ new Set();
   }
 });
 
@@ -23609,7 +24695,7 @@ is not a problem with esbuild. You need to fix your environment instead.
         let latestResultPromise;
         let provideLatestResult;
         if (isContext)
-          requestCallbacks["on-end"] = (id, request2) => new Promise((resolve26) => {
+          requestCallbacks["on-end"] = (id, request2) => new Promise((resolve27) => {
             buildResponseToResult(request2, (err, result2, onEndErrors, onEndWarnings) => {
               const response = {
                 errors: onEndErrors,
@@ -23619,7 +24705,7 @@ is not a problem with esbuild. You need to fix your environment instead.
               latestResultPromise = void 0;
               provideLatestResult = void 0;
               sendResponse(id, response);
-              resolve26();
+              resolve27();
             });
           });
         sendRequest(refs, request, (error, response) => {
@@ -23636,10 +24722,10 @@ is not a problem with esbuild. You need to fix your environment instead.
           let didDispose = false;
           const result2 = {
             rebuild: () => {
-              if (!latestResultPromise) latestResultPromise = new Promise((resolve26, reject) => {
+              if (!latestResultPromise) latestResultPromise = new Promise((resolve27, reject) => {
                 let settlePromise;
                 provideLatestResult = (err, result22) => {
-                  if (!settlePromise) settlePromise = () => err ? reject(err) : resolve26(result22);
+                  if (!settlePromise) settlePromise = () => err ? reject(err) : resolve27(result22);
                 };
                 const triggerAnotherBuild = () => {
                   const request2 = {
@@ -23660,7 +24746,7 @@ is not a problem with esbuild. You need to fix your environment instead.
               });
               return latestResultPromise;
             },
-            watch: (options22 = {}) => new Promise((resolve26, reject) => {
+            watch: (options22 = {}) => new Promise((resolve27, reject) => {
               if (!streamIn.hasFS) throw new Error(`Cannot use the "watch" API in this environment`);
               const keys = {};
               const delay = getFlag(options22, keys, "delay", mustBeInteger);
@@ -23672,10 +24758,10 @@ is not a problem with esbuild. You need to fix your environment instead.
               if (delay) request2.delay = delay;
               sendRequest(refs, request2, (error2) => {
                 if (error2) reject(new Error(error2));
-                else resolve26(void 0);
+                else resolve27(void 0);
               });
             }),
-            serve: (options22 = {}) => new Promise((resolve26, reject) => {
+            serve: (options22 = {}) => new Promise((resolve27, reject) => {
               if (!streamIn.hasFS) throw new Error(`Cannot use the "serve" API in this environment`);
               const keys = {};
               const port2 = getFlag(options22, keys, "port", mustBeValidPortNumber);
@@ -23713,28 +24799,28 @@ is not a problem with esbuild. You need to fix your environment instead.
                     sendResponse(id, {});
                   };
                 }
-                resolve26(response2);
+                resolve27(response2);
               });
             }),
-            cancel: () => new Promise((resolve26) => {
-              if (didDispose) return resolve26();
+            cancel: () => new Promise((resolve27) => {
+              if (didDispose) return resolve27();
               const request2 = {
                 command: "cancel",
                 key: buildKey
               };
               sendRequest(refs, request2, () => {
-                resolve26();
+                resolve27();
               });
             }),
-            dispose: () => new Promise((resolve26) => {
-              if (didDispose) return resolve26();
+            dispose: () => new Promise((resolve27) => {
+              if (didDispose) return resolve27();
               didDispose = true;
               const request2 = {
                 command: "dispose",
                 key: buildKey
               };
               sendRequest(refs, request2, () => {
-                resolve26();
+                resolve27();
                 scheduleOnDisposeCallbacks();
                 refs.unref();
               });
@@ -23773,7 +24859,7 @@ is not a problem with esbuild. You need to fix your environment instead.
             onLoad: []
           };
           i++;
-          let resolve26 = (path3, options2 = {}) => {
+          let resolve27 = (path3, options2 = {}) => {
             if (!isSetupDone) throw new Error('Cannot call "resolve" before plugin setup has completed');
             if (typeof path3 !== "string") throw new Error(`The path to resolve must be a string`);
             let keys2 = /* @__PURE__ */ Object.create(null);
@@ -23785,7 +24871,7 @@ is not a problem with esbuild. You need to fix your environment instead.
             let pluginData = getFlag(options2, keys2, "pluginData", canBeAnything);
             let importAttributes = getFlag(options2, keys2, "with", mustBeObject);
             checkForInvalidFlags(options2, keys2, "in resolve() call");
-            return new Promise((resolve27, reject) => {
+            return new Promise((resolve28, reject) => {
               const request = {
                 command: "resolve",
                 path: path3,
@@ -23802,7 +24888,7 @@ is not a problem with esbuild. You need to fix your environment instead.
               if (importAttributes != null) request.with = sanitizeStringMap(importAttributes, "with");
               sendRequest(refs, request, (error, response) => {
                 if (error !== null) reject(new Error(error));
-                else resolve27({
+                else resolve28({
                   errors: replaceDetailsInMessages(response.errors, details),
                   warnings: replaceDetailsInMessages(response.warnings, details),
                   path: response.path,
@@ -23817,7 +24903,7 @@ is not a problem with esbuild. You need to fix your environment instead.
           };
           let promise = setup({
             initialOptions,
-            resolve: resolve26,
+            resolve: resolve27,
             onStart(callback) {
               let registeredText = `This error came from the "onStart" callback registered here:`;
               let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onStart");
@@ -24510,46 +25596,46 @@ More information: The file containing the code for esbuild's JavaScript API (${_
         }
       };
       longLivedService = {
-        build: (options2) => new Promise((resolve26, reject) => {
+        build: (options2) => new Promise((resolve27, reject) => {
           service.buildOrContext({
             callName: "build",
             refs,
             options: options2,
             isTTY: isTTY(),
             defaultWD,
-            callback: (err, res) => err ? reject(err) : resolve26(res)
+            callback: (err, res) => err ? reject(err) : resolve27(res)
           });
         }),
-        context: (options2) => new Promise((resolve26, reject) => service.buildOrContext({
+        context: (options2) => new Promise((resolve27, reject) => service.buildOrContext({
           callName: "context",
           refs,
           options: options2,
           isTTY: isTTY(),
           defaultWD,
-          callback: (err, res) => err ? reject(err) : resolve26(res)
+          callback: (err, res) => err ? reject(err) : resolve27(res)
         })),
-        transform: (input, options2) => new Promise((resolve26, reject) => service.transform({
+        transform: (input, options2) => new Promise((resolve27, reject) => service.transform({
           callName: "transform",
           refs,
           input,
           options: options2 || {},
           isTTY: isTTY(),
           fs: fsAsync,
-          callback: (err, res) => err ? reject(err) : resolve26(res)
+          callback: (err, res) => err ? reject(err) : resolve27(res)
         })),
-        formatMessages: (messages, options2) => new Promise((resolve26, reject) => service.formatMessages({
+        formatMessages: (messages, options2) => new Promise((resolve27, reject) => service.formatMessages({
           callName: "formatMessages",
           refs,
           messages,
           options: options2,
-          callback: (err, res) => err ? reject(err) : resolve26(res)
+          callback: (err, res) => err ? reject(err) : resolve27(res)
         })),
-        analyzeMetafile: (metafile, options2) => new Promise((resolve26, reject) => service.analyzeMetafile({
+        analyzeMetafile: (metafile, options2) => new Promise((resolve27, reject) => service.analyzeMetafile({
           callName: "analyzeMetafile",
           refs,
           metafile: typeof metafile === "string" ? metafile : JSON.stringify(metafile),
           options: options2,
-          callback: (err, res) => err ? reject(err) : resolve26(res)
+          callback: (err, res) => err ? reject(err) : resolve27(res)
         }))
       };
       return longLivedService;
@@ -24627,13 +25713,13 @@ error: ${text}`);
         worker.postMessage(msg);
         let status = Atomics.wait(sharedBufferView, 0, 0);
         if (status !== "ok" && status !== "not-equal") throw new Error("Internal error: Atomics.wait() failed: " + status);
-        let { message: { id: id2, resolve: resolve26, reject, properties } } = worker_threads2.receiveMessageOnPort(mainPort);
+        let { message: { id: id2, resolve: resolve27, reject, properties } } = worker_threads2.receiveMessageOnPort(mainPort);
         if (id !== id2) throw new Error(`Internal error: Expected id ${id} but got id ${id2}`);
         if (reject) {
           applyProperties(reject, properties);
           throw reject;
         }
-        return resolve26;
+        return resolve27;
       };
       worker.unref();
       return {
@@ -25025,8 +26111,8 @@ var init_server_head = __esm({
 
 // ../compiler/src/actions.ts
 import { walk as walk2 } from "zimmerframe";
-import { print as print3 } from "esrap";
-import ts3 from "esrap/languages/ts";
+import { print as print4 } from "esrap";
+import ts4 from "esrap/languages/ts";
 function hashString2(str) {
   let h1 = 2166136261;
   let h2 = 16777619;
@@ -25090,7 +26176,7 @@ function printWithTypesStripped(ast, code, hadTs = hasTsSyntax(ast)) {
     stripped.body = stripped.body.filter((n) => !isTypeOnlyStatement(n));
   }
   try {
-    return print3(stripped, ts3()).code;
+    return print4(stripped, ts4()).code;
   } catch {
     return code;
   }
@@ -25163,8 +26249,8 @@ var init_actions = __esm({
 });
 
 // ../compiler/src/md-inline.ts
-import { readFileSync, existsSync as existsSync3 } from "node:fs";
-import { dirname as dirname3, join as join2, resolve as resolve3 } from "node:path";
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname4, join as join3, resolve as resolve4 } from "node:path";
 function looksLikeMarkdownPath(value) {
   const v = value.trim();
   if (v.length === 0 || v.length > 4096) return false;
@@ -25201,7 +26287,7 @@ function inlineMdContentAttrs(source, importerDir, mdRoots = []) {
               if (abs !== null) {
                 let contents;
                 try {
-                  contents = readFileSync(abs, "utf-8");
+                  contents = readFileSync2(abs, "utf-8");
                 } catch {
                   out += source[i];
                   i++;
@@ -25228,14 +26314,14 @@ function resolveMdPath(specifier, importerDir, roots) {
   const spec = specifier.trim();
   if (isRelativeSpecifier(spec)) {
     if (!importerDir) return null;
-    const abs = resolve3(importerDir, spec);
+    const abs = resolve4(importerDir, spec);
     return existsSync3(abs) ? abs : null;
   }
   if (spec.startsWith("/")) {
     for (const root3 of roots) {
-      const pub = join2(root3, "public", spec);
+      const pub = join3(root3, "public", spec);
       if (existsSync3(pub)) return pub;
-      const direct = join2(root3, spec);
+      const direct = join3(root3, spec);
       if (existsSync3(direct)) return direct;
     }
   }
@@ -25247,15 +26333,15 @@ function guessProjectRoots(dir) {
   let cur = dir;
   for (let i = 0; i < 6; i++) {
     roots.push(cur);
-    if (existsSync3(join2(cur, "package.json"))) break;
-    const parent = dirname3(cur);
+    if (existsSync3(join3(cur, "package.json"))) break;
+    const parent = dirname4(cur);
     if (parent === cur) break;
     cur = parent;
   }
   return roots;
 }
 function inlineMdImportsFrom(source, importerFile, mdRoots = []) {
-  const dir = importerFile ? dirname3(importerFile) : null;
+  const dir = importerFile ? dirname4(importerFile) : null;
   return inlineMdContentAttrs(source, dir, mdRoots.length > 0 ? mdRoots : [dir || process.cwd()]);
 }
 var MD_EXT_MARKER;
@@ -25268,8 +26354,8 @@ var init_md_inline = __esm({
 
 // ../compiler/src/client-codegen.ts
 import { walk as walk3 } from "zimmerframe";
-import { print as print4 } from "esrap";
-import ts4 from "esrap/languages/ts";
+import { print as print5 } from "esrap";
+import ts5 from "esrap/languages/ts";
 import tsx from "esrap/languages/tsx";
 function callExpr(callee, args2 = []) {
   return { type: "CallExpression", callee, arguments: args2, optional: false };
@@ -25306,7 +26392,7 @@ function containsJsx(node, depth = 0) {
   return false;
 }
 function printAst(ast) {
-  return print4(ast, containsJsx(ast) ? tsx() : ts4()).code;
+  return print5(ast, containsJsx(ast) ? tsx() : ts5()).code;
 }
 function transformTracked(irNode, tracked2) {
   const ast = irNode.ast;
@@ -25390,7 +26476,7 @@ function transformTracked(irNode, tracked2) {
       return context.next();
     }
   });
-  return print4(transformed, containsJsx(transformed) ? tsx() : ts4()).code;
+  return print5(transformed, containsJsx(transformed) ? tsx() : ts5()).code;
 }
 function collectTrackedNames(body) {
   const names = /* @__PURE__ */ new Map();
@@ -26471,7 +27557,12 @@ function emitClientFromIR(ir, options2) {
       runtimeNames.push(name);
     }
   }
-  const runtimeImport = `import { ${runtimeNames.join(", ")} } from '@vesk/runtime';`;
+  const boundLocally = /* @__PURE__ */ new Set();
+  for (const imp of ir.imports) {
+    for (const pair of importBindingPairs(imp)) boundLocally.add(pair.local);
+  }
+  const shadowedRuntimeNames = runtimeNames.filter((n) => !boundLocally.has(n));
+  const runtimeImport = `import { ${shadowedRuntimeNames.length > 0 ? shadowedRuntimeNames.join(", ") : "destroy_block"} } from '@vesk/runtime';`;
   const moduleCode = `
 ${runtimeImport}
 ${importLines}
@@ -26517,6 +27608,7 @@ var init_client_codegen = __esm({
     init_ir_generator();
     init_actions();
     init_server_utils();
+    init_module_imports();
     init_scan();
     init_md_inline();
     init_strip_ts();
@@ -26973,18 +28065,21 @@ function generateFunctionBody(comp, importedNames) {
 function buildComponentMap2(irRoot, useSharedScope) {
   const map = /* @__PURE__ */ new Map();
   const runtimeNames = extractRuntimeNames(irRoot.imports);
-  const importedNames = new Set(runtimeNames);
+  const localValueNames = localValueImportNames(irRoot.imports);
+  const importedNames = /* @__PURE__ */ new Set([...runtimeNames, ...localValueNames]);
   const topNames = extractTopLevelNames(irRoot.topLevelCode);
   const hasTracked = irRoot.components.some((c) => c.body.some((n) => n instanceof TrackDecl));
   const extraNames = hasTracked ? ["get", "set", "track"] : [];
-  const allNames = [.../* @__PURE__ */ new Set([...runtimeNames, ...topNames, ...extraNames])];
+  const allNames = [.../* @__PURE__ */ new Set([...runtimeNames, ...topNames, ...extraNames, ...localValueNames])];
   const scopeDecl = allNames.length > 0 ? `const { ${allNames.join(", ")} } = __vesk;
 ` : "";
   setVskImportedNames(importedNames);
   for (const comp of irRoot.components) {
     const bodyCode = generateFunctionBody(comp, importedNames);
     const paramInit = buildParamInit(comp.paramNames);
-    const code = `${scopeDecl}${paramInit}
+    const diag = process.env.VESK_SSR_LOG ? `console.error('[SSR-CALL]', ${JSON.stringify(comp.name)}, props ? JSON.stringify(props) : String(props));
+` : "";
+    const code = `${scopeDecl}${paramInit}${diag}
 ${bodyCode}`;
     let fn;
     if (comp.isAsync || comp.ssrAwait) {
@@ -27007,6 +28102,7 @@ var init_server_jsgen = __esm({
     init_client_codegen();
     init_scan();
     init_server_utils();
+    init_module_imports();
     __currentCompName = "";
   }
 });
@@ -27056,34 +28152,39 @@ __export(server_render_exports, {
   renderPageStream: () => renderPageStream,
   ssg: () => ssg
 });
-import { readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
 function compileFile(source, options2) {
   return compileFileInternal(source, options2?.sourcePath, /* @__PURE__ */ new Set());
 }
 function compileFileInternal(source, sourcePath2, seenImportFiles) {
   if (sourcePath2) {
-    const dir = dirname4(sourcePath2);
+    const dir = dirname5(sourcePath2);
     source = inlineMdImportsFrom(source, sourcePath2, guessProjectRoots(dir));
   }
   const ast = parse4(source);
   const ir = generateIR(ast, source);
   const componentMap = buildComponentMap2(ir, true);
+  const __vesk = loadRuntimeImports(ir.imports);
+  applyLocalModuleImports(__vesk, ir.imports, sourcePath2);
   if (sourcePath2) {
     for (const importPath of collectVskImportPaths(ir.imports, sourcePath2)) {
       if (seenImportFiles.has(importPath)) continue;
       seenImportFiles.add(importPath);
       try {
-        const importedSrc = readFileSync2(importPath, "utf-8");
+        const importedSrc = readFileSync3(importPath, "utf-8");
         const sub = compileFileInternal(importedSrc, importPath, seenImportFiles);
         for (const [name, fn] of sub.componentMap) {
           if (!componentMap.has(name)) componentMap.set(name, fn);
         }
+        for (const key of Object.keys(sub.__vesk)) {
+          if (key in __vesk) continue;
+          __vesk[key] = sub.__vesk[key];
+        }
       } catch {
       }
     }
   }
-  const __vesk = loadRuntimeImports(ir.imports);
   evalTopLevelCode(transformTopLevelForActions(ir.topLevelCode, "server"), __vesk);
   return { ir, componentMap, __vesk };
 }
@@ -27341,7 +28442,11 @@ function renderPageStream(source, componentName, props = {}, registry = /* @__PU
     const ir = cached ? cached.ir : generateIR(parse4(source), source);
     let ssrProps = { ...props };
     let serializedProps = null;
-    let __vesk = options2.__vesk || cached?.__vesk || loadRuntimeImports(ir.imports);
+    let __vesk = options2.__vesk || cached?.__vesk || null;
+    if (!__vesk) {
+      __vesk = loadRuntimeImports(ir.imports);
+      applyLocalModuleImports(__vesk, ir.imports, options2.sourcePath || void 0);
+    }
     if (ir.loadFn) {
       const loadResult = await callLoadFunction(ir.loadFn, props, __vesk);
       if (loadResult && typeof loadResult === "object") {
@@ -27428,18 +28533,38 @@ var init_server_render = __esm({
     init_vsk_imports();
     init_md_inline();
     init_ssr_store();
+    init_module_imports();
   }
 });
 
 // ../adapter/src/paths.ts
-import { resolve as resolve8, sep as sep2 } from "node:path";
+import { resolve as resolve9, sep as sep2 } from "node:path";
+import { existsSync as existsSync8, statSync as statSync4, readFileSync as readFileSync9 } from "node:fs";
 function resolveWithin(baseDir, relPath) {
-  const base = resolve8(baseDir);
-  const target = resolve8(baseDir, relPath);
+  const base = resolve9(baseDir);
+  const target = resolve9(baseDir, relPath);
   const prefix = base + sep2;
   if (!target.startsWith(prefix)) return null;
   return target;
 }
+function installMdReadHook(publicDirs) {
+  const dirs = publicDirs.map((d) => resolve9(d));
+  globalThis.__vsk_md_read_file = (p) => {
+    for (const dir of dirs) {
+      try {
+        let rel = String(p);
+        while (rel.length > 0 && rel.charCodeAt(0) === 47) rel = rel.slice(1);
+        const abs = resolveWithin(dir, rel);
+        if (!abs) continue;
+        const lower = abs.toLowerCase();
+        if (!lower.endsWith(".md") && !lower.endsWith(".markdown")) continue;
+        if (existsSync8(abs) && statSync4(abs).isFile()) return readFileSync9(abs, "utf8");
+      } catch {
+      }
+    }
+    return null;
+  };
+}
 var init_paths = __esm({
   "../adapter/src/paths.ts"() {
     "use strict";
@@ -27454,20 +28579,20 @@ __export(static_exports, {
   generateSitemap: () => generateSitemap,
   generateSsgRoutes: () => generateSsgRoutes
 });
-import { mkdirSync as mkdirSync2, copyFileSync as copyFileSync2, readdirSync as readdirSync3, statSync as statSync5, existsSync as existsSync10, writeFileSync as writeFileSync4, readFileSync as readFileSync10 } from "node:fs";
-import { resolve as resolve11, join as join6 } from "node:path";
+import { mkdirSync as mkdirSync2, copyFileSync as copyFileSync2, readdirSync as readdirSync3, statSync as statSync7, existsSync as existsSync11, writeFileSync as writeFileSync4, readFileSync as readFileSync12 } from "node:fs";
+import { resolve as resolve12, join as join7 } from "node:path";
 function copyStaticAssets2(publicDir, outDir2) {
-  const targetDir = resolve11(outDir2, "static", "public");
+  const targetDir = resolve12(outDir2, "static", "public");
   mkdirSync2(targetDir, { recursive: true });
-  if (!existsSync10(publicDir))
+  if (!existsSync11(publicDir))
     return;
   function copyDir(src2, dest) {
     mkdirSync2(dest, { recursive: true });
     const entries = readdirSync3(src2);
     for (const entry of entries) {
-      const srcPath = join6(src2, entry);
-      const destPath = join6(dest, entry);
-      const st = statSync5(srcPath);
+      const srcPath = join7(src2, entry);
+      const destPath = join7(dest, entry);
+      const st = statSync7(srcPath);
       if (st.isDirectory()) {
         copyDir(srcPath, destPath);
       } else {
@@ -27479,7 +28604,7 @@ function copyStaticAssets2(publicDir, outDir2) {
 }
 async function generateSsgRoutes(routeTree, appDir, outDir2) {
   const { ssg: ssg2 } = await Promise.resolve().then(() => (init_server_render(), server_render_exports));
-  const prerenderDir = resolve11(outDir2, "prerendered");
+  const prerenderDir = resolve12(outDir2, "prerendered");
   mkdirSync2(prerenderDir, { recursive: true });
   const results = [];
   async function evaluateExport(src2, exportName) {
@@ -27498,8 +28623,8 @@ async function generateSsgRoutes(routeTree, appDir, outDir2) {
   async function walk6(nodes) {
     for (const node of nodes) {
       if (node.page) {
-        const pagePath = resolve11(appDir, node.sourceDir, "page.vsk");
-        const src2 = readFileSync10(pagePath, "utf-8");
+        const pagePath = resolve12(appDir, node.sourceDir, "page.vsk");
+        const src2 = readFileSync12(pagePath, "utf-8");
         const hasStaticProps = src2.includes("getStaticProps");
         const hasStaticPaths = src2.includes("getStaticPaths");
         if (hasStaticPaths) {
@@ -27516,7 +28641,7 @@ async function generateSsgRoutes(routeTree, appDir, outDir2) {
                   console.error(`vesk: SSG path escaped output dir \u2014 skipping ${pagePath} (path: ${urlPath})`);
                   continue;
                 }
-                mkdirSync2(resolve11(htmlPath, ".."), { recursive: true });
+                mkdirSync2(resolve12(htmlPath, ".."), { recursive: true });
                 writeFileSync4(htmlPath, result2.html);
                 results.push({ path: urlPath, html: htmlPath, static: result2.static, params });
               } catch (e) {
@@ -27528,8 +28653,8 @@ async function generateSsgRoutes(routeTree, appDir, outDir2) {
         } else if (hasStaticProps) {
           try {
             const result2 = await ssg2(src2, null, void 0, {});
-            const htmlPath = resolve11(prerenderDir, node.fullPath === "/" ? "index.html" : `${node.fullPath.slice(1)}.html`);
-            mkdirSync2(resolve11(htmlPath, ".."), { recursive: true });
+            const htmlPath = resolve12(prerenderDir, node.fullPath === "/" ? "index.html" : `${node.fullPath.slice(1)}.html`);
+            mkdirSync2(resolve12(htmlPath, ".."), { recursive: true });
             writeFileSync4(htmlPath, result2.html);
             results.push({ path: node.fullPath, html: htmlPath, static: result2.static });
           } catch (e) {
@@ -27599,15 +28724,15 @@ var image_pipeline_exports = {};
 __export(image_pipeline_exports, {
   optimizeImages: () => optimizeImages
 });
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync5, readFileSync as readFileSync11, existsSync as existsSync11, readdirSync as readdirSync4, statSync as statSync6 } from "node:fs";
-import { resolve as resolve12, extname as extname3, dirname as dirname7 } from "node:path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync5, readFileSync as readFileSync13, existsSync as existsSync12, readdirSync as readdirSync4, statSync as statSync8 } from "node:fs";
+import { resolve as resolve13, extname as extname4, dirname as dirname8 } from "node:path";
 async function processImage(srcPath, outDir2, baseName) {
   const image = sharpFn ? sharpFn(srcPath) : null;
   if (!image) {
-    const original = readFileSync11(srcPath);
+    const original = readFileSync13(srcPath);
     for (const w of OUTPUT_WIDTHS) {
-      const outputPath = resolve12(outDir2, `${baseName}-${w}w`);
-      mkdirSync3(dirname7(outputPath), { recursive: true });
+      const outputPath = resolve13(outDir2, `${baseName}-${w}w`);
+      mkdirSync3(dirname8(outputPath), { recursive: true });
       writeFileSync5(outputPath, original);
     }
     return [];
@@ -27620,12 +28745,12 @@ async function processImage(srcPath, outDir2, baseName) {
       continue;
     const resized = image.clone().resize({ width: w, withoutEnlargement: true });
     const base = `${baseName}-${w}w`;
-    const jpgPath = resolve12(outDir2, `${base}${extname3(srcPath)}`);
-    mkdirSync3(dirname7(jpgPath), { recursive: true });
+    const jpgPath = resolve13(outDir2, `${base}${extname4(srcPath)}`);
+    mkdirSync3(dirname8(jpgPath), { recursive: true });
     await resized.toFile(jpgPath);
     generated.push(jpgPath);
     for (const fmt of FORMATS) {
-      const fmtPath = resolve12(outDir2, `${base}.${fmt}`);
+      const fmtPath = resolve13(outDir2, `${base}.${fmt}`);
       await resized.toFormat(fmt, { quality: 80 }).toFile(fmtPath);
       generated.push(fmtPath);
     }
@@ -27642,14 +28767,14 @@ function collectImageRefs(appDir) {
       return;
     }
     for (const entry of entries) {
-      const full = resolve12(dir, entry);
-      const st = statSync6(full);
+      const full = resolve13(dir, entry);
+      const st = statSync8(full);
       if (st.isDirectory()) {
         if (entry.startsWith("."))
           continue;
         walk6(full);
       } else if (entry === "page.vsk") {
-        const src2 = readFileSync11(full, "utf-8");
+        const src2 = readFileSync13(full, "utf-8");
         const imgRegex = /<Image\s+src=["']([^"']+)["']/g;
         let m;
         while ((m = imgRegex.exec(src2)) !== null) {
@@ -27662,7 +28787,7 @@ function collectImageRefs(appDir) {
   return refs;
 }
 async function optimizeImages(appDir, outDir2) {
-  const imageOutDir = resolve12(outDir2, "static", "images");
+  const imageOutDir = resolve13(outDir2, "static", "images");
   mkdirSync3(imageOutDir, { recursive: true });
   const refs = collectImageRefs(appDir);
   if (refs.length === 0) {
@@ -27672,14 +28797,14 @@ async function optimizeImages(appDir, outDir2) {
   const results = [];
   for (const ref2 of refs) {
     const possiblePaths = [
-      resolve12(appDir, ref2.src),
-      resolve12(appDir, "..", "public", ref2.src.replace(/^\//, "")),
-      resolve12(appDir, "..", "src", ref2.src.replace(/^\//, "")),
-      resolve12(outDir2, "static", "public", ref2.src.replace(/^\//, ""))
+      resolve13(appDir, ref2.src),
+      resolve13(appDir, "..", "public", ref2.src.replace(/^\//, "")),
+      resolve13(appDir, "..", "src", ref2.src.replace(/^\//, "")),
+      resolve13(outDir2, "static", "public", ref2.src.replace(/^\//, ""))
     ];
     let srcPath = null;
     for (const p of possiblePaths) {
-      if (existsSync11(p)) {
+      if (existsSync12(p)) {
         srcPath = p;
         break;
       }
@@ -27688,12 +28813,12 @@ async function optimizeImages(appDir, outDir2) {
       console.error(`vesk images: not found \u2014 ${ref2.src} (referenced by ${ref2.source})`);
       continue;
     }
-    const ext = extname3(srcPath).toLowerCase();
+    const ext = extname4(srcPath).toLowerCase();
     if (!SUPPORTED.has(ext)) {
       console.error(`vesk images: unsupported format \u2014 ${ref2.src} (${ext})`);
       continue;
     }
-    const baseName = ref2.src.replace(/^\//, "").replace(extname3(ref2.src), "");
+    const baseName = ref2.src.replace(/^\//, "").replace(extname4(ref2.src), "");
     const files = await processImage(srcPath, imageOutDir, baseName);
     results.push({ src: ref2.src, baseName, files, widths: OUTPUT_WIDTHS });
     console.error(`vesk images: ${ref2.src} \u2192 ${files.length} variants`);
@@ -27726,8 +28851,8 @@ var seo_audit_exports = {};
 __export(seo_audit_exports, {
   runSeoAudit: () => runSeoAudit
 });
-import { readFileSync as readFileSync12, existsSync as existsSync12, readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
-import { resolve as resolve13 } from "node:path";
+import { readFileSync as readFileSync14, existsSync as existsSync13, readdirSync as readdirSync5, statSync as statSync9 } from "node:fs";
+import { resolve as resolve14 } from "node:path";
 function walkFiles(dir) {
   const results = [];
   let entries;
@@ -27737,8 +28862,8 @@ function walkFiles(dir) {
     return results;
   }
   for (const entry of entries) {
-    const full = resolve13(dir, entry);
-    const st = statSync7(full);
+    const full = resolve14(dir, entry);
+    const st = statSync9(full);
     if (st.isDirectory()) {
       if (!entry.startsWith("."))
         results.push(...walkFiles(full));
@@ -27752,10 +28877,10 @@ function collectCombinedSource(appDir) {
   const pages = files.filter((f) => f.endsWith("/page.vsk") || f.endsWith("\\page.vsk"));
   const combined = [];
   for (const pagePath of pages) {
-    const dir = resolve13(pagePath, "..");
-    const layoutPath = resolve13(dir, "layout.vsk");
-    const pageSrc = readFileSync12(pagePath, "utf-8");
-    const layoutSrc = existsSync12(layoutPath) ? readFileSync12(layoutPath, "utf-8") : "";
+    const dir = resolve14(pagePath, "..");
+    const layoutPath = resolve14(dir, "layout.vsk");
+    const pageSrc = readFileSync14(pagePath, "utf-8");
+    const layoutSrc = existsSync13(layoutPath) ? readFileSync14(layoutPath, "utf-8") : "";
     const combinedSrc = layoutSrc ? layoutSrc + "\n" + pageSrc : pageSrc;
     combined.push({
       path: pagePath,
@@ -27930,8 +29055,8 @@ var init_platform = __esm({
 });
 
 // ../adapter/src/platform-handler.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { resolve as resolve14, dirname as dirname8 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import { resolve as resolve15, dirname as dirname9 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function routeName2(segments) {
   const parts = segments.filter(Boolean).map((s) => {
@@ -27948,8 +29073,8 @@ function toId(s) {
   return s.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^_/, "");
 }
 function findCompilerSrc2() {
-  const monorepo = resolve14(__dirname5, "..", "..", "..", "packages", "compiler", "dist");
-  if (existsSync13(monorepo)) return monorepo;
+  const monorepo = resolve15(__dirname5, "..", "..", "..", "packages", "compiler", "dist");
+  if (existsSync14(monorepo)) return monorepo;
   throw new Error('@vesk/compiler/dist not found \u2014 run "npm run build" first');
 }
 function generatePlatformHandlerSource(input) {
@@ -27980,7 +29105,7 @@ function generatePlatformHandlerSource(input) {
 ` : "const __prerendered = new Set();\n";
   const isrCache = "const __isrCache = new Map();";
   const compilerSrc = findCompilerSrc2();
-  const parseCookiesImport = hasMiddleware ? `import { parseCookies } from ${JSON.stringify(resolve14(compilerSrc, "server-cookies.js"))};` : "";
+  const parseCookiesImport = hasMiddleware ? `import { parseCookies } from ${JSON.stringify(resolve15(compilerSrc, "server-cookies.js"))};` : "";
   return `
 ${imports}
 ${parseCookiesImport}
@@ -28018,7 +29143,7 @@ export async function handleRequest(request) {
     return new Response(null, { status: 308, headers: { Location: '/_vesk/static/public' + (pathname.endsWith('/') ? pathname + 'index.html' : pathname + '.html') } });
   }
 
-  let mwCtx = { params: {}, url, locals: {}, cookies: {}, request, set() {}, get() { return undefined; } };
+  let mwCtx = { params: {}, url, locals: {}, cookies: {}, request, resolveUrl(u) { return new URL(u, request.url).href; }, set() {}, get() { return undefined; } };
   if (${hasMwLiteral}) {
     mwCtx = {
       request,
@@ -28026,6 +29151,7 @@ export async function handleRequest(request) {
       url,
       locals: {},
       cookies: typeof parseCookies !== 'undefined' ? parseCookies(request.headers.get('cookie') || '') : {},
+      resolveUrl(u) { return new URL(u, request.url).href; },
       set(key, value) { this.locals[key] = value; },
       get(key) { return this.locals[key]; },
     };
@@ -28080,7 +29206,7 @@ async function bundlePlatformHandler(options2) {
     plugins.push({
       name: "empty-node-builtins",
       setup(build5) {
-        const builtins = /^(node:)?(fs|path|child_process|os|crypto|net|stream|buffer|events|util|url|querystring|http|https|zlib|tty|async_hooks)$/;
+        const builtins = /^(node:)?(fs|module|path|child_process|os|crypto|net|stream|buffer|events|util|url|querystring|http|https|zlib|tty|async_hooks)$/;
         build5.onResolve({ filter: builtins }, (args2) => {
           return { path: args2.path, namespace: "empty-node" };
         });
@@ -28108,14 +29234,19 @@ export const readFileSync = () => {};
 export const writeFileSync = () => {};
 export const existsSync = () => {};
 export const statSync = () => {};
+export const realpathSync = () => '';
 export const readdirSync = () => {};
 export const mkdirSync = () => {};
 export const unlinkSync = () => {};
 export const rmSync = () => {};
 export const copyFileSync = () => {};
 export const accessSync = () => {};
+// node:module \u2014 createRequire is server-only dead code in the browser bundle;
+// the stub keeps esbuild from failing on the named import.
+export const createRequire = () => () => undefined;
 export const join = (...a) => a.join('/');
 export const resolve = (...a) => a.join('/');
+export const isAbsolute = () => false;
 export const dirname = () => '';
 export const basename = () => '';
 export const extname = () => '';
@@ -28155,7 +29286,7 @@ var __dirname5;
 var init_platform_handler = __esm({
   "../adapter/src/platform-handler.ts"() {
     "use strict";
-    __dirname5 = dirname8(fileURLToPath4(import.meta.url));
+    __dirname5 = dirname9(fileURLToPath4(import.meta.url));
   }
 });
 
@@ -28164,74 +29295,74 @@ import {
   mkdirSync as mkdirSync4,
   copyFileSync as copyFileSync3,
   readdirSync as readdirSync6,
-  statSync as statSync8,
-  existsSync as existsSync14,
+  statSync as statSync10,
+  existsSync as existsSync15,
   writeFileSync as writeFileSync6,
   rmSync,
-  readFileSync as readFileSync13
+  readFileSync as readFileSync15
 } from "node:fs";
-import { resolve as resolve15, join as join7, extname as extname4, dirname as dirname9 } from "node:path";
+import { resolve as resolve16, join as join8, extname as extname5, dirname as dirname10 } from "node:path";
 function ensureCleanDir(dir) {
   rmSync(dir, { recursive: true, force: true });
   mkdirSync4(dir, { recursive: true });
 }
 function copyDirContents(srcDir, destDir) {
-  if (!existsSync14(srcDir)) return;
+  if (!existsSync15(srcDir)) return;
   mkdirSync4(destDir, { recursive: true });
   for (const entry of readdirSync6(srcDir)) {
-    const srcPath = join7(srcDir, entry);
-    const destPath = join7(destDir, entry);
-    if (statSync8(srcPath).isDirectory()) {
+    const srcPath = join8(srcDir, entry);
+    const destPath = join8(destDir, entry);
+    if (statSync10(srcPath).isDirectory()) {
       copyDirContents(srcPath, destPath);
     } else {
-      mkdirSync4(dirname9(destPath), { recursive: true });
+      mkdirSync4(dirname10(destPath), { recursive: true });
       copyFileSync3(srcPath, destPath);
     }
   }
 }
 function writeFile(path, content) {
-  mkdirSync4(dirname9(path), { recursive: true });
+  mkdirSync4(dirname10(path), { recursive: true });
   writeFileSync6(path, content, "utf-8");
 }
 function writePlatformStatic(buildStaticDir, platformStaticDir) {
   mkdirSync4(platformStaticDir, { recursive: true });
-  const publicDir = resolve15(buildStaticDir, "public");
-  if (existsSync14(publicDir)) {
+  const publicDir = resolve16(buildStaticDir, "public");
+  if (existsSync15(publicDir)) {
     copyDirContents(publicDir, platformStaticDir);
   }
-  const assetsDir = resolve15(platformStaticDir, "_vesk", "static");
+  const assetsDir = resolve16(platformStaticDir, "_vesk", "static");
   copyDirContents(buildStaticDir, assetsDir);
-  const runtimeAlias = resolve15(platformStaticDir, "_vesk", "runtime.js");
-  const clientPath = resolve15(buildStaticDir, "client.js");
-  if (existsSync14(clientPath)) {
-    mkdirSync4(dirname9(runtimeAlias), { recursive: true });
+  const runtimeAlias = resolve16(platformStaticDir, "_vesk", "runtime.js");
+  const clientPath = resolve16(buildStaticDir, "client.js");
+  if (existsSync15(clientPath)) {
+    mkdirSync4(dirname10(runtimeAlias), { recursive: true });
     copyFileSync3(clientPath, runtimeAlias);
   }
 }
 function writePrerenderedStatic(prerenderedRoutes, platformStaticDir) {
   for (const route of prerenderedRoutes) {
-    if (!existsSync14(route.html)) continue;
-    const content = readFileSync13(route.html);
+    if (!existsSync15(route.html)) continue;
+    const content = readFileSync15(route.html);
     const htmlRel = route.path === "/" ? "index.html" : `${route.path.replace(/^\//, "")}.html`;
-    const target = resolve15(platformStaticDir, "_vesk", "static", "public", htmlRel);
+    const target = resolve16(platformStaticDir, "_vesk", "static", "public", htmlRel);
     writeFile(target, content);
     if (route.path !== "/" && route.path.endsWith("/")) {
-      const dirIndex = resolve15(platformStaticDir, "_vesk", "static", "public", `${route.path.replace(/^\//, "")}index.html`);
+      const dirIndex = resolve16(platformStaticDir, "_vesk", "static", "public", `${route.path.replace(/^\//, "")}index.html`);
       writeFile(dirIndex, content);
     }
   }
 }
 function listStaticDir(dir) {
   const out = [];
-  if (!existsSync14(dir)) return out;
+  if (!existsSync15(dir)) return out;
   function walk6(d, prefix) {
     for (const entry of readdirSync6(d)) {
-      const full = join7(d, entry);
+      const full = join8(d, entry);
       const rel = prefix ? `${prefix}/${entry}` : entry;
-      if (statSync8(full).isDirectory()) {
+      if (statSync10(full).isDirectory()) {
         walk6(full, rel);
       } else {
-        out.push({ rel, buffer: readFileSync13(full) });
+        out.push({ rel, buffer: readFileSync15(full) });
       }
     }
   }
@@ -28239,7 +29370,7 @@ function listStaticDir(dir) {
   return out;
 }
 function mimeFor(path) {
-  return MIME2[extname4(path).toLowerCase()] || "application/octet-stream";
+  return MIME2[extname5(path).toLowerCase()] || "application/octet-stream";
 }
 var MIME2;
 var init_platform_output = __esm({
@@ -28279,7 +29410,7 @@ __export(platform_deploy_exports, {
   emitPlatformOutput: () => emitPlatformOutput
 });
 import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync5, rmSync as rmSync2, symlinkSync } from "node:fs";
-import { resolve as resolve16, dirname as dirname10, relative as relative3 } from "node:path";
+import { resolve as resolve17, dirname as dirname11, relative as relative3 } from "node:path";
 async function emitPlatformOutput(platform, ctx2) {
   if (platform === "node") return null;
   const prerenderedPaths = ctx2.prerenderedRoutes.map((r) => r.path);
@@ -28290,13 +29421,13 @@ async function emitPlatformOutput(platform, ctx2) {
     hasMiddleware: ctx2.hasMiddleware
   });
   const shell = shellFor(platform);
-  const projectRoot = resolve16(ctx2.outDir, "..");
-  const outRoot = resolve16(projectRoot, shell.root);
+  const projectRoot = resolve17(ctx2.outDir, "..");
+  const outRoot = resolve17(projectRoot, shell.root);
   ensureCleanDir(outRoot);
-  const staticDir2 = shell.staticSubdir === "" ? outRoot : resolve16(outRoot, shell.staticSubdir || "static");
-  writePlatformStatic(resolve16(ctx2.outDir, "static"), staticDir2);
+  const staticDir2 = shell.staticSubdir === "" ? outRoot : resolve17(outRoot, shell.staticSubdir || "static");
+  writePlatformStatic(resolve17(ctx2.outDir, "static"), staticDir2);
   writePrerenderedStatic(ctx2.prerenderedRoutes, staticDir2);
-  const entry = resolve16(ctx2.outDir, ".platform-entry.mjs");
+  const entry = resolve17(ctx2.outDir, ".platform-entry.mjs");
   let source = handler;
   if (shell.imports) source = `${shell.imports}
 ${source}`;
@@ -28314,24 +29445,24 @@ ${shell.bootstrap}
   writeFileSync7(entry, source, "utf-8");
   let handlerRel;
   if (shell.functionFile) {
-    const funcDir = resolve16(outRoot, shell.functionFile.dir);
+    const funcDir = resolve17(outRoot, shell.functionFile.dir);
     mkdirSync5(funcDir, { recursive: true });
     if (shell.functionConfig) {
-      writeFileSync7(resolve16(funcDir, ".vc-config.json"), JSON.stringify(shell.functionConfig, null, 2), "utf-8");
+      writeFileSync7(resolve17(funcDir, ".vc-config.json"), JSON.stringify(shell.functionConfig, null, 2), "utf-8");
     }
     handlerRel = `${shell.functionFile.dir}/${shell.functionFile.file}`;
-    await bundlePlatformHandler({ entry, outfile: resolve16(funcDir, shell.functionFile.file), nodeBuiltins: shell.nodeBuiltins });
+    await bundlePlatformHandler({ entry, outfile: resolve17(funcDir, shell.functionFile.file), nodeBuiltins: shell.nodeBuiltins });
   } else {
     handlerRel = shell.outfile || "index.js";
-    await bundlePlatformHandler({ entry, outfile: resolve16(outRoot, handlerRel), nodeBuiltins: shell.nodeBuiltins });
+    await bundlePlatformHandler({ entry, outfile: resolve17(outRoot, handlerRel), nodeBuiltins: shell.nodeBuiltins });
   }
   for (const file of shell.extraFiles || []) {
-    writeFileSync7(resolve16(outRoot, file.path), file.content, "utf-8");
+    writeFileSync7(resolve17(outRoot, file.path), file.content, "utf-8");
   }
   if (platform === "vercel") {
-    writeFileSync7(resolve16(outRoot, "config.json"), vercelConfigJson(prerenderedPaths), "utf-8");
+    writeFileSync7(resolve17(outRoot, "config.json"), vercelConfigJson(prerenderedPaths), "utf-8");
   }
-  writeFileSync7(resolve16(outRoot, "manifest.json"), JSON.stringify({
+  writeFileSync7(resolve17(outRoot, "manifest.json"), JSON.stringify({
     platform,
     runtime: shell.nodeBuiltins ? "node" : "edge",
     static: shell.staticMode,
@@ -28341,11 +29472,11 @@ ${shell.bootstrap}
     prerendered: prerenderedPaths
   }, null, 2), "utf-8");
   if (platform === "vercel") {
-    const vercelDir = resolve16(projectRoot, ".vercel");
+    const vercelDir = resolve17(projectRoot, ".vercel");
     mkdirSync5(vercelDir, { recursive: true });
-    const linkPath = resolve16(vercelDir, "output");
+    const linkPath = resolve17(vercelDir, "output");
     rmSync2(linkPath, { recursive: true, force: true });
-    symlinkSync(relative3(dirname10(linkPath), outRoot), linkPath, "dir");
+    symlinkSync(relative3(dirname11(linkPath), outRoot), linkPath, "dir");
   }
   rmSync2(entry, { force: true });
   return outRoot;
@@ -30518,6 +31649,95 @@ function wireCopyHandlers2(root3) {
 function mdIsSSR2() {
   return typeof document === "undefined";
 }
+function stringEndsWith2(s, suffix) {
+  if (suffix.length > s.length)
+    return false;
+  for (let i = 0; i < suffix.length; i++) {
+    if (s[s.length - suffix.length + i] !== suffix[i])
+      return false;
+  }
+  return true;
+}
+function isPublicMarkdownPath2(v) {
+  if (typeof v !== "string")
+    return false;
+  const s = v;
+  if (s.length < 2 || s.charCodeAt(0) !== 47)
+    return false;
+  if (s.charCodeAt(1) === 47)
+    return false;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 63 || c === 35 || c === 92)
+      return false;
+  }
+  const lower = s.toLowerCase();
+  return stringEndsWith2(lower, ".md") || stringEndsWith2(lower, ".markdown");
+}
+function getMdPathCell2(path) {
+  let cell = mdPathCells2.get(path);
+  if (!cell) {
+    cell = tracked(void 0);
+    mdPathCells2.set(path, cell);
+  }
+  return cell;
+}
+function ensureMdPathLoaded2(path) {
+  if (mdPathCache2.has(path) || mdPathInflight2.has(path))
+    return;
+  const ssr = getSsrData("md:" + path);
+  if (typeof ssr === "string") {
+    mdPathCache2.set(path, ssr);
+    return;
+  }
+  mdPathInflight2.add(path);
+  fetch(path).then((r) => r.ok ? r.text() : Promise.reject(r)).then((text) => {
+    mdPathCache2.set(path, text);
+    set(getMdPathCell2(path), text);
+  }).catch(() => {
+    mdPathCache2.set(path, null);
+    set(getMdPathCell2(path), null);
+  }).finally(() => {
+    mdPathInflight2.delete(path);
+  });
+}
+function readServerMdPath2(path) {
+  const hook = globalThis.__vsk_md_read_file;
+  if (typeof hook !== "function")
+    return null;
+  try {
+    const out = hook(path);
+    if (typeof out === "string")
+      return out;
+  } catch {
+  }
+  return null;
+}
+function resolveMdSource2(value) {
+  const s = String(value ?? "");
+  if (!isPublicMarkdownPath2(s))
+    return s;
+  if (mdIsSSR2()) {
+    const content = readServerMdPath2(s);
+    if (content !== null) {
+      setSsrData("md:" + s, content);
+      return content;
+    }
+    return s;
+  }
+  ensureMdPathLoaded2(s);
+  const cached = mdPathCache2.get(s);
+  return cached === void 0 || cached === null ? s : cached;
+}
+function streamCellFrom2(rawContent) {
+  if (rawContent === null || typeof rawContent !== "object")
+    return null;
+  const into = rawContent.into;
+  if (into !== null && typeof into === "object" && typeof into.get === "function") {
+    return into;
+  }
+  return null;
+}
 function buildHtml2(content, props) {
   const global = getMdPolicy2();
   const mode = props.html || global.html;
@@ -30553,8 +31773,10 @@ function buildHtml2(content, props) {
 }
 function Md2(props, _registry, hydrate) {
   const rawContent = props.content;
-  const content = String(unwrapMaybeCell2(rawContent) ?? "");
-  const html = buildHtml2(content, props);
+  const streamTarget = streamCellFrom2(rawContent);
+  const contentCell = streamTarget ?? rawContent;
+  const content = String(unwrapMaybeCell2(contentCell) ?? "");
+  const html = buildHtml2(resolveMdSource2(content), props);
   const classNameRaw = props.className != null ? String(props.className) : props.class != null ? String(props.class) : "";
   const themeClass = props.theme === "dark" ? " vesk-md-dark" : "";
   const className = `vesk-md${themeClass}${classNameRaw ? " " + classNameRaw : ""}`;
@@ -30567,7 +31789,8 @@ function Md2(props, _registry, hydrate) {
   if (propFg && propFg !== "none")
     wrapperParts.push(`--md-code-fg:${propFg}`);
   const wrapperStyle = wrapperParts.length > 0 ? escapeHtml6(wrapperParts.join(";")) : "";
-  const reactive = isCell2(rawContent);
+  const reactive = isCell2(contentCell);
+  const pathMode = isPublicMarkdownPath2(content);
   if (mdIsSSR2()) {
     const attrs = className ? ` class="${escapeHtml6(className)}"` : "";
     const styleAttr = style || wrapperStyle ? ` style="${[wrapperStyle, style.split('"').join("&quot;")].filter(Boolean).join(";")}"` : "";
@@ -30580,12 +31803,20 @@ function Md2(props, _registry, hydrate) {
       if (existing)
         el = existing;
     }
-    el.innerHTML = html;
+    const claimed = !!el.parentNode;
+    if (pathMode && claimed) {
+      el.setAttribute("data-vsk-md-ssr", "1");
+      if (mdPathCache2.has(content))
+        el.innerHTML = html;
+    } else {
+      el.innerHTML = html;
+    }
     el.className = className;
     el.style.cssText = [wrapperStyle, style].filter(Boolean).join(";");
     wireCopyHandlers2(el);
-    if (reactive)
-      subscribeContent2(el, rawContent, props);
+    if (reactive || pathMode) {
+      subscribeContent2(el, contentCell, props, pathMode && claimed ? { trustInitialSsr: true, initialValue: content } : void 0);
+    }
     if (el.parentNode)
       return document.createDocumentFragment();
     return el;
@@ -30595,22 +31826,42 @@ function Md2(props, _registry, hydrate) {
   div.className = className;
   div.style.cssText = [wrapperStyle, style].filter(Boolean).join(";");
   wireCopyHandlers2(div);
-  if (reactive)
-    subscribeContent2(div, rawContent, props);
+  if (reactive || pathMode)
+    subscribeContent2(div, contentCell, props);
   return div;
 }
-function subscribeContent2(el, rawContent, props) {
+function subscribeContent2(el, rawContent, props, opts) {
+  const trust = opts?.trustInitialSsr === true;
+  const initial = opts?.initialValue;
+  let ran = false;
   effect(() => {
     const value = String(unwrapMaybeCell2(rawContent) ?? "");
-    el.innerHTML = buildHtml2(value, props);
+    if (isPublicMarkdownPath2(value)) {
+      const known = getSsrData("md:" + value) !== void 0 || mdPathCache2.has(value);
+      ensureMdPathLoaded2(value);
+      const cell = getMdPathCell2(value);
+      get(cell);
+      if (trust && !ran && value === initial && !known) {
+        ran = true;
+        return;
+      }
+      ran = true;
+      el.innerHTML = buildHtml2(resolveMdSource2(value), props);
+      wireCopyHandlers2(el);
+      return;
+    }
+    ran = true;
+    el.innerHTML = buildHtml2(resolveMdSource2(value), props);
     wireCopyHandlers2(el);
   });
 }
-var COLOR_FUNCS2, SAFE_SCHEMES2, KW_JS2, KW_VSK2, LIT_JS2, KW_PY2, LIT_PY2, KW_GO2, LIT_GO2, KW_RUST2, LIT_RUST2, KW_SQL2, KW_BASH2, NAMED_ENTITIES2, URL_ATTRS2, MD_DEFAULT_ALLOW_TAGS2, MD_BASE_CSS2, __globalMode2, __globalAllowTags2, __sessionWarnings2, __warnedKeys2, __suppressMdConsoleWarnings2;
+var COLOR_FUNCS2, SAFE_SCHEMES2, KW_JS2, KW_VSK2, LIT_JS2, KW_PY2, LIT_PY2, KW_GO2, LIT_GO2, KW_RUST2, LIT_RUST2, KW_SQL2, KW_BASH2, NAMED_ENTITIES2, URL_ATTRS2, MD_DEFAULT_ALLOW_TAGS2, MD_BASE_CSS2, __globalMode2, __globalAllowTags2, __sessionWarnings2, __warnedKeys2, __suppressMdConsoleWarnings2, mdPathCache2, mdPathCells2, mdPathInflight2;
 var init_md2 = __esm({
   "../runtime/dist/md.js"() {
     "use strict";
     init_ripple_blocks();
+    init_ripple_runtime();
+    init_resource();
     COLOR_FUNCS2 = /* @__PURE__ */ new Set(["rgb", "rgba", "hsl", "hsla", "hwb", "lab", "lch", "oklab", "oklch", "color", "color-mix"]);
     SAFE_SCHEMES2 = ["http:", "https:", "mailto:", "tel:"];
     KW_JS2 = /* @__PURE__ */ new Set([
@@ -31012,6 +32263,9 @@ var init_md2 = __esm({
     __sessionWarnings2 = [];
     __warnedKeys2 = /* @__PURE__ */ new Set();
     __suppressMdConsoleWarnings2 = false;
+    mdPathCache2 = /* @__PURE__ */ new Map();
+    mdPathCells2 = /* @__PURE__ */ new Map();
+    mdPathInflight2 = /* @__PURE__ */ new Set();
   }
 });
 
@@ -31466,6 +32720,11 @@ function emitJSXChildren(g2, source, children, opts) {
     } else if (child.type === "JSXFragment") {
       emitJSXFragment(g2, source, child, opts);
       i++;
+    } else if (child.type === "IfStatement" || child.type === "ForOfStatement" || child.type === "ForStatement" || child.type === "ForInStatement" || child.type === "WhileStatement" || child.type === "DoWhileStatement" || child.type === "SwitchStatement" || child.type === "TryStatement" || child.type === "VariableDeclaration" || child.type === "ExpressionStatement") {
+      g2.addRaw("{(() => { ");
+      emitBody(g2, source, [child], "", opts);
+      g2.addRaw(" })()}");
+      i++;
     } else {
       i++;
     }
@@ -31978,9 +33237,9 @@ __export(typecheck_exports, {
   formatTypecheckWarnings: () => formatTypecheckWarnings,
   typecheckProject: () => typecheckProject
 });
-import { readFileSync as readFileSync20, readdirSync as readdirSync12, statSync as statSync14 } from "node:fs";
-import { join as join13, dirname as dirname14, normalize, relative as relative7, resolve as resolve24, sep as sep5 } from "node:path";
-import * as ts7 from "typescript";
+import { readFileSync as readFileSync23, readdirSync as readdirSync12, statSync as statSync17 } from "node:fs";
+import { join as join14, dirname as dirname15, normalize, relative as relative7, resolve as resolve25, sep as sep5 } from "node:path";
+import * as ts8 from "typescript";
 function walkProjectFiles(projectRoot) {
   const code = [];
   const js = [];
@@ -31992,10 +33251,10 @@ function walkProjectFiles(projectRoot) {
       return;
     }
     for (const e of entries) {
-      const p = join13(dir, e);
+      const p = join14(dir, e);
       let st;
       try {
-        st = statSync14(p);
+        st = statSync17(p);
       } catch {
         continue;
       }
@@ -32020,8 +33279,8 @@ function walkProjectFiles(projectRoot) {
   return { code, js };
 }
 function isUnder(dir, file) {
-  const base = resolve24(dir);
-  const abs = resolve24(file);
+  const base = resolve25(dir);
+  const abs = resolve25(file);
   return abs === base || abs.startsWith(base + sep5);
 }
 function structureWarning(rel, message) {
@@ -32047,10 +33306,10 @@ function checkStructureFile(appDir, file) {
   return null;
 }
 function createTypecheckHost(projectRoot, appDir, vskFiles) {
-  const ambientPath = join13(appDir, "__vesk_ambient.d.ts");
-  const overridePath = join13(appDir, "__vesk_runtime_override.d.ts");
+  const ambientPath = join14(appDir, "__vesk_ambient.d.ts");
+  const overridePath = join14(appDir, "__vesk_runtime_override.d.ts");
   const cached = /* @__PURE__ */ new Map();
-  const scriptKindFor = (file) => file.endsWith(".vsk") ? ts7.ScriptKind.TSX : ts7.ScriptKind.TS;
+  const scriptKindFor = (file) => file.endsWith(".vsk") ? ts8.ScriptKind.TSX : ts8.ScriptKind.TS;
   const host2 = {
     getSourceFile(file, langVersion, onError, shouldCreateNewSourceFile) {
       if (!shouldCreateNewSourceFile && cached.has(file))
@@ -32062,21 +33321,21 @@ function createTypecheckHost(projectRoot, appDir, vskFiles) {
         content = RUNTIME_OVERRIDE;
       } else if (file.endsWith(".vsk.d.ts")) {
         const vskPath = file.slice(0, -".d.ts".length);
-        const src2 = vskFiles.get(vskPath) ?? (ts7.sys.fileExists(vskPath) ? ts7.sys.readFile(vskPath) : void 0);
+        const src2 = vskFiles.get(vskPath) ?? (ts8.sys.fileExists(vskPath) ? ts8.sys.readFile(vskPath) : void 0);
         content = src2 !== void 0 ? generateVskDts(src2) : void 0;
       } else if (file.endsWith(".css.d.ts")) {
         content = "";
       } else if (vskFiles.has(file)) {
         content = vskToTsx(vskFiles.get(file));
-      } else if (ts7.sys.fileExists(file)) {
-        content = ts7.sys.readFile(file);
+      } else if (ts8.sys.fileExists(file)) {
+        content = ts8.sys.readFile(file);
       }
       if (content === void 0) {
         if (onError)
           onError(`File not found: ${file}`);
         return void 0;
       }
-      const sf = ts7.createSourceFile(file, content, langVersion, true, scriptKindFor(file));
+      const sf = ts8.createSourceFile(file, content, langVersion, true, scriptKindFor(file));
       cached.set(file, sf);
       return sf;
     },
@@ -32087,13 +33346,13 @@ function createTypecheckHost(projectRoot, appDir, vskFiles) {
         return true;
       if (file.endsWith(".vsk.d.ts")) {
         const vskPath = file.slice(0, -".d.ts".length);
-        return vskFiles.has(vskPath) || ts7.sys.fileExists(vskPath);
+        return vskFiles.has(vskPath) || ts8.sys.fileExists(vskPath);
       }
       if (file.endsWith(".css.d.ts"))
         return true;
       if (vskFiles.has(file))
         return true;
-      return ts7.sys.fileExists(file);
+      return ts8.sys.fileExists(file);
     },
     readFile(file) {
       if (file === ambientPath)
@@ -32102,55 +33361,55 @@ function createTypecheckHost(projectRoot, appDir, vskFiles) {
         return RUNTIME_OVERRIDE;
       if (file.endsWith(".vsk.d.ts")) {
         const vskPath = file.slice(0, -".d.ts".length);
-        const src2 = vskFiles.get(vskPath) ?? (ts7.sys.fileExists(vskPath) ? ts7.sys.readFile(vskPath) : void 0);
+        const src2 = vskFiles.get(vskPath) ?? (ts8.sys.fileExists(vskPath) ? ts8.sys.readFile(vskPath) : void 0);
         return src2 !== void 0 ? generateVskDts(src2) : void 0;
       }
       if (file.endsWith(".css.d.ts"))
         return "";
       if (vskFiles.has(file))
         return vskToTsx(vskFiles.get(file));
-      return ts7.sys.readFile(file);
+      return ts8.sys.readFile(file);
     },
     writeFile: () => {
     },
     getCurrentDirectory: () => projectRoot,
-    getDefaultLibFileName: (o) => ts7.getDefaultLibFilePath(o),
-    directoryExists: (dir) => ts7.sys.directoryExists(dir),
+    getDefaultLibFileName: (o) => ts8.getDefaultLibFilePath(o),
+    directoryExists: (dir) => ts8.sys.directoryExists(dir),
     getDirectories: (dir) => {
       try {
-        return readdirSync12(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join13(dir, d.name));
+        return readdirSync12(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join14(dir, d.name));
       } catch {
         return [];
       }
     },
     getCanonicalFileName: (f) => normalize(f),
-    useCaseSensitiveFileNames: () => ts7.sys.useCaseSensitiveFileNames,
+    useCaseSensitiveFileNames: () => ts8.sys.useCaseSensitiveFileNames,
     getNewLine: () => "\n",
     resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options2) {
       return moduleLiterals.map(({ text }) => {
         if (text.endsWith(".vsk")) {
-          const abs = normalize(join13(dirname14(containingFile), text));
+          const abs = normalize(join14(dirname15(containingFile), text));
           return {
             resolvedModule: {
               resolvedFileName: abs + ".d.ts",
-              extension: ts7.Extension.Dts,
+              extension: ts8.Extension.Dts,
               isExternalLibraryImport: false
             },
             failedLookupLocations: []
           };
         }
         if (text.endsWith(".css")) {
-          const abs = normalize(join13(dirname14(containingFile), text));
+          const abs = normalize(join14(dirname15(containingFile), text));
           return {
             resolvedModule: {
               resolvedFileName: abs + ".d.ts",
-              extension: ts7.Extension.Dts,
+              extension: ts8.Extension.Dts,
               isExternalLibraryImport: false
             },
             failedLookupLocations: []
           };
         }
-        const res = ts7.resolveModuleName(text, containingFile, options2, host2);
+        const res = ts8.resolveModuleName(text, containingFile, options2, host2);
         return { resolvedModule: res.resolvedModule, failedLookupLocations: [] };
       });
     }
@@ -32158,7 +33417,7 @@ function createTypecheckHost(projectRoot, appDir, vskFiles) {
   return host2;
 }
 function typecheckProject(projectRoot, opts = {}) {
-  const appDir = opts.appDir ?? join13(projectRoot, "app");
+  const appDir = opts.appDir ?? join14(projectRoot, "app");
   const vskFiles = /* @__PURE__ */ new Map();
   const parseErrors = [];
   const warnings = [];
@@ -32180,7 +33439,7 @@ function typecheckProject(projectRoot, opts = {}) {
       }
     }
     if (f.endsWith(".vsk")) {
-      const src2 = readFileSync20(f, "utf-8");
+      const src2 = readFileSync23(f, "utf-8");
       try {
         parse4(src2);
       } catch (e) {
@@ -32197,16 +33456,16 @@ function typecheckProject(projectRoot, opts = {}) {
     }
     rootNames.push(f);
   }
-  const ambientPath = join13(appDir, "__vesk_ambient.d.ts");
-  const overridePath = join13(appDir, "__vesk_runtime_override.d.ts");
+  const ambientPath = join14(appDir, "__vesk_ambient.d.ts");
+  const overridePath = join14(appDir, "__vesk_runtime_override.d.ts");
   rootNames.push(ambientPath);
   rootNames.push(overridePath);
   const options2 = {
-    target: ts7.ScriptTarget.ES2022,
-    module: ts7.ModuleKind.ESNext,
-    moduleResolution: ts7.ModuleResolutionKind.Bundler,
+    target: ts8.ScriptTarget.ES2022,
+    module: ts8.ModuleKind.ESNext,
+    moduleResolution: ts8.ModuleResolutionKind.Bundler,
     strict: opts.strict !== false,
-    jsx: ts7.JsxEmit.Preserve,
+    jsx: ts8.JsxEmit.Preserve,
     noEmit: true,
     skipLibCheck: true,
     esModuleInterop: true,
@@ -32219,13 +33478,13 @@ function typecheckProject(projectRoot, opts = {}) {
     allowJs: false
   };
   const host2 = createTypecheckHost(projectRoot, appDir, vskFiles);
-  const program = ts7.createProgram({ rootNames, options: options2, host: host2 });
+  const program = ts8.createProgram({ rootNames, options: options2, host: host2 });
   const rootSet = new Set(rootNames.map(normalize));
   const vskSet = /* @__PURE__ */ new Set();
   for (const p of vskFiles.keys())
     vskSet.add(normalize(p));
   const errors = [...parseErrors];
-  for (const diag of ts7.getPreEmitDiagnostics(program)) {
+  for (const diag of ts8.getPreEmitDiagnostics(program)) {
     const file = diag.file;
     if (!file)
       continue;
@@ -32242,7 +33501,7 @@ function typecheckProject(projectRoot, opts = {}) {
       line: pos.line + 1,
       column: pos.character + 1,
       code,
-      message: ts7.flattenDiagnosticMessageText(diag.messageText, "\n")
+      message: ts8.flattenDiagnosticMessageText(diag.messageText, "\n")
     });
   }
   return { errors, warnings };
@@ -32675,6 +33934,11 @@ declare function useFetch<T = unknown>(
   urlOrFn: string | (() => Promise<T>),
   options?: VeskUseFetchOptions<T>,
 ): VeskResource<T>;
+declare namespace useFetch {
+  function text<T = string>(url: string, options?: Omit<VeskUseFetchOptions<T>, 'body'>): VeskResource<T>;
+  function json<T = unknown>(url: string, options?: Omit<VeskUseFetchOptions<T>, 'body'>): VeskResource<T>;
+  function arrayBuffer<T = ArrayBuffer>(url: string, options?: Omit<VeskUseFetchOptions<T>, 'body'>): VeskResource<T>;
+}
 declare function useRouter(): unknown;
 declare function useParams(): Record<string, string>;
 declare function usePathname(): string;
@@ -32757,8 +34021,8 @@ declare module '@vesk/runtime' {
 });
 
 // src/index.ts
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync11, mkdirSync as mkdirSync9, existsSync as existsSync23 } from "fs";
-import { resolve as resolve25, join as join14, dirname as dirname15 } from "path";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync11, mkdirSync as mkdirSync9, existsSync as existsSync25 } from "fs";
+import { resolve as resolve26, join as join15, dirname as dirname16 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 
 // ../compiler/dist/config.js
@@ -33257,41 +34521,41 @@ function setRuntimeModule2(mod) {
 
 // ../adapter/dist/index.js
 init_scan();
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync8, existsSync as existsSync15, readFileSync as readFileSync14 } from "node:fs";
-import { resolve as resolve17, dirname as dirname11, relative as relative4 } from "node:path";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync8, existsSync as existsSync16, readFileSync as readFileSync16 } from "node:fs";
+import { resolve as resolve18, dirname as dirname12, relative as relative4 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // ../adapter/src/runtime-bundle.ts
 init_esbuild_fallback();
 import { writeFileSync, existsSync as existsSync2, unlinkSync } from "node:fs";
-import { resolve as resolve2, dirname as dirname2, join } from "node:path";
+import { resolve as resolve3, dirname as dirname3, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var buildId = 0;
-var __dirname2 = dirname2(fileURLToPath(import.meta.url));
+var __dirname2 = dirname3(fileURLToPath(import.meta.url));
 function findCompilerSrc(appDir) {
-  const monorepoRoot = resolve2(__dirname2, "..", "..", "..");
+  const monorepoRoot = resolve3(__dirname2, "..", "..", "..");
   const candidates = [
-    resolve2(monorepoRoot, "packages", "compiler", "dist"),
-    resolve2(appDir, "..", "node_modules", "@vesk/compiler"),
-    resolve2(appDir, "node_modules", "@vesk/compiler")
+    resolve3(monorepoRoot, "packages", "compiler", "dist"),
+    resolve3(appDir, "..", "node_modules", "@vesk/compiler"),
+    resolve3(appDir, "node_modules", "@vesk/compiler")
   ];
   for (const base of candidates) {
-    for (const dir of [base, join(base, "dist")]) {
-      if (existsSync2(join(dir, "server-codegen.js"))) return dir;
+    for (const dir of [base, join2(base, "dist")]) {
+      if (existsSync2(join2(dir, "server-codegen.js"))) return dir;
     }
   }
   throw new Error('@vesk/compiler/dist not found \u2014 run "npm run build" first');
 }
 function findRuntimeSrc(appDir) {
-  const monorepoRoot = resolve2(__dirname2, "..", "..", "..");
+  const monorepoRoot = resolve3(__dirname2, "..", "..", "..");
   const candidates = [
-    resolve2(monorepoRoot, "packages", "runtime", "dist"),
-    resolve2(appDir, "..", "node_modules", "@vesk/runtime"),
-    resolve2(appDir, "node_modules", "@vesk/runtime")
+    resolve3(monorepoRoot, "packages", "runtime", "dist"),
+    resolve3(appDir, "..", "node_modules", "@vesk/runtime"),
+    resolve3(appDir, "node_modules", "@vesk/runtime")
   ];
   for (const base of candidates) {
-    for (const dir of [base, join(base, "dist")]) {
-      if (existsSync2(join(dir, "index-server.js"))) return dir;
+    for (const dir of [base, join2(base, "dist")]) {
+      if (existsSync2(join2(dir, "index-server.js"))) return dir;
     }
   }
   throw new Error('@vesk/runtime/dist not found \u2014 run "npm run build" first');
@@ -33299,11 +34563,11 @@ function findRuntimeSrc(appDir) {
 async function bundleRuntime(appDir, outDir2) {
   const compilerRoot = findCompilerSrc(appDir);
   const runtimeRoot = findRuntimeSrc(appDir);
-  const entryFile = resolve2(outDir2, "server", `.runtime-entry-${buildId++}.mjs`);
+  const entryFile = resolve3(outDir2, "server", `.runtime-entry-${buildId++}.mjs`);
   const entryContent = [
-    `import { renderPage, renderFullPage, renderPageStream, compileFile, setRuntimeModule, setVskHydrate, assertSameOrigin } from ${JSON.stringify(resolve2(compilerRoot, "server-codegen.js"))};`,
-    `import { parseCookies } from ${JSON.stringify(resolve2(compilerRoot, "server-cookies.js"))};`,
-    `import * as __veskRuntime from ${JSON.stringify(resolve2(runtimeRoot, "index-server.js"))};`,
+    `import { renderPage, renderFullPage, renderPageStream, compileFile, setRuntimeModule, setVskHydrate, assertSameOrigin } from ${JSON.stringify(resolve3(compilerRoot, "server-codegen.js"))};`,
+    `import { parseCookies } from ${JSON.stringify(resolve3(compilerRoot, "server-cookies.js"))};`,
+    `import * as __veskRuntime from ${JSON.stringify(resolve3(runtimeRoot, "index-server.js"))};`,
     "",
     "// Inject runtime module so server-codegen can find components like NavLink, Link, etc.",
     "setRuntimeModule(__veskRuntime);",
@@ -33384,8 +34648,8 @@ async function bundleRuntime(appDir, outDir2) {
       platform: "neutral",
       format: "esm",
       minify: true,
-      outfile: resolve2(outDir2, "server", "runtime.js"),
-      external: ["fs", "node:fs", "path", "node:path", "node:async_hooks"],
+      outfile: resolve3(outDir2, "server", "runtime.js"),
+      external: ["fs", "node:fs", "path", "node:path", "module", "node:module", "node:async_hooks"],
       target: ["es2022"],
       treeShaking: true
     });
@@ -33395,7 +34659,7 @@ async function bundleRuntime(appDir, outDir2) {
     if (result2.warnings.length > 0) {
       for (const w of result2.warnings) console.error("vesk build warning:", w.text);
     }
-    return resolve2(outDir2, "server", "runtime.js");
+    return resolve3(outDir2, "server", "runtime.js");
   } finally {
     try {
       unlinkSync(entryFile);
@@ -33405,8 +34669,8 @@ async function bundleRuntime(appDir, outDir2) {
 }
 
 // ../adapter/src/ssr-function.ts
-import { readFileSync as readFileSync3, existsSync as existsSync5 } from "node:fs";
-import { resolve as resolve5, relative, join as join3 } from "node:path";
+import { readFileSync as readFileSync4, existsSync as existsSync5 } from "node:fs";
+import { resolve as resolve6, relative, join as join4 } from "node:path";
 
 // ../compiler/src/server-codegen.ts
 init_server_utils();
@@ -33421,8 +34685,8 @@ function escapeSource(src2) {
 function resolveErrorFile(sourceDir, appDir) {
   const rel = relative(appDir, sourceDir).split("/").filter(Boolean);
   for (let depth = rel.length; depth >= 0; depth--) {
-    const dir = depth === 0 ? appDir : join3(appDir, ...rel.slice(0, depth));
-    const p = join3(dir, "error.vsk");
+    const dir = depth === 0 ? appDir : join4(appDir, ...rel.slice(0, depth));
+    const p = join4(dir, "error.vsk");
     if (existsSync5(p)) return p;
   }
   return null;
@@ -33474,27 +34738,27 @@ function buildParamExtraction(node, urlParts) {
 function generateSsrFunction(routeNode, appDir, outDir2, componentMap, options2) {
   const ancestorLayouts = options2?.ancestorLayouts || [];
   const middlewareCode = options2?.middlewareCode || null;
-  const pagePath = resolve5(appDir, routeNode.sourceDir, "page.vsk");
-  const layoutPath = resolve5(appDir, routeNode.sourceDir, "layout.vsk");
+  const pagePath = resolve6(appDir, routeNode.sourceDir, "page.vsk");
+  const layoutPath = resolve6(appDir, routeNode.sourceDir, "layout.vsk");
   const parts = routeNode.fullPath.split("/").filter(Boolean);
   const name = routeName(parts);
-  const funcDir = resolve5(outDir2, "server", "functions");
-  const funcPath = resolve5(funcDir, `${name}.js`);
-  const tailwindPath = resolve5(outDir2, "static", "_tailwind.css");
-  const globalCssPath = resolve5(appDir, "..", "src", "global.css");
-  const altCssPath = resolve5(appDir, "..", "src", "app.css");
+  const funcDir = resolve6(outDir2, "server", "functions");
+  const funcPath = resolve6(funcDir, `${name}.js`);
+  const tailwindPath = resolve6(outDir2, "static", "_tailwind.css");
+  const globalCssPath = resolve6(appDir, "..", "src", "global.css");
+  const altCssPath = resolve6(appDir, "..", "src", "app.css");
   const hasGlobalCss = existsSync5(globalCssPath) || existsSync5(altCssPath);
-  const hasTailwind = existsSync5(tailwindPath) && readFileSync3(tailwindPath, "utf-8").trim().length > 0;
+  const hasTailwind = existsSync5(tailwindPath) && readFileSync4(tailwindPath, "utf-8").trim().length > 0;
   const cssUrls = [];
   if (hasTailwind) cssUrls.push("/_vesk/static/_tailwind.css");
   if (hasGlobalCss) cssUrls.push("/_vesk/static/global.css");
   const cssOption = cssUrls.length > 0 ? `, cssUrls: ${JSON.stringify(cssUrls)}` : "";
   const hasLayout = !!routeNode.layout;
   const hasAncestorLayout = ancestorLayouts.length > 0;
-  const pageSrc = readFileSync3(pagePath, "utf-8");
+  const pageSrc = readFileSync4(pagePath, "utf-8");
   const pageComp = extractCompName(pageSrc) || "Page";
   const errorPath = resolveErrorFile(routeNode.sourceDir, appDir);
-  const errorSrc = errorPath ? readFileSync3(errorPath, "utf-8") : null;
+  const errorSrc = errorPath ? readFileSync4(errorPath, "utf-8") : null;
   const errorComp = errorPath ? extractCompName(errorSrc) || "Error" : null;
   const errorVars = errorPath ? `const _errorSrc = \`${escapeSource(errorSrc)}\`;
 const _errorComp = ${JSON.stringify(errorComp)};
@@ -33503,7 +34767,7 @@ const _errorCompiled = (() => { try { setVskHydrate(true); return compileFile(_e
 ` : "const _errorSrc = null;\nconst _errorComp = null;\nconst _errorPath = null;\nconst _errorCompiled = null;\n";
   let src2 = "";
   if (hasLayout) {
-    const layoutSrc = readFileSync3(layoutPath, "utf-8");
+    const layoutSrc = readFileSync4(layoutPath, "utf-8");
     const layoutComp = extractCompName(layoutSrc) || "Layout";
     src2 = `const _layoutSrc = \`${escapeSource(layoutSrc)}\`;
 const _pageSrc = \`${escapeSource(pageSrc)}\`;
@@ -33521,8 +34785,8 @@ const _pagePath = ${JSON.stringify(pagePath)};
     src2 += errorVars;
   } else if (hasAncestorLayout) {
     const outerLayout = ancestorLayouts[0];
-    const outerLayoutPath = resolve5(appDir, outerLayout.sourceDir, "layout.vsk");
-    const outerLayoutSrc = readFileSync3(outerLayoutPath, "utf-8");
+    const outerLayoutPath = resolve6(appDir, outerLayout.sourceDir, "layout.vsk");
+    const outerLayoutSrc = readFileSync4(outerLayoutPath, "utf-8");
     const outerLayoutComp = extractCompName(outerLayoutSrc) || "Layout";
     src2 = `const _pageSrc = \`${escapeSource(pageSrc)}\`;
 `;
@@ -33563,7 +34827,7 @@ const _comp = ${JSON.stringify(pageComp)};
   const compRegEntries = [];
   const compMap = componentMap || /* @__PURE__ */ new Map();
   for (const [compName, compPath] of compMap) {
-    const compSrc = readFileSync3(compPath, "utf-8");
+    const compSrc = readFileSync4(compPath, "utf-8");
     const escapedSrc = escapeSource(compSrc);
     compRegEntries.push(`  registry.set(${JSON.stringify(compName)}, async (props, __registry, __vesk) => {
     const _src = \`${escapedSrc}\`;
@@ -33709,6 +34973,7 @@ ${compRegEntries.join("\n")}
       "    url,",
       "    locals: Object.assign({}, __rootLocals),",
       "    cookies: parseCookies(request.headers.get('cookie') || ''),",
+      "    resolveUrl(u) { return new URL(u, request.url).href; },",
       "    set(key, value) { this.locals[key] = value; },",
       "    get(key) { return this.locals[key]; },",
       "  };",
@@ -33724,7 +34989,17 @@ ${compRegEntries.join("\n")}
       "  }"
     ].join("\n");
   } else {
-    bodyCode = dataCode;
+    const indentedRender = dataCode.split("\n").map((l) => l ? `  ${l}` : "").join("\n");
+    bodyCode = [
+      "  // Request context for SSR helpers (useParams/useRequest, relative useFetch resolution).",
+      "  const prevReq = globalThis.__vesk_request;",
+      "  globalThis.__vesk_request = VeskRequest.from(request, { params });",
+      "  try {",
+      indentedRender,
+      "  } finally {",
+      "    globalThis.__vesk_request = prevReq;",
+      "  }"
+    ].join("\n");
   }
   let registerActionsCode;
   if (hasLayout || hasAncestorLayout) {
@@ -33797,6 +35072,7 @@ ${compRegEntries.join("\n")}
     "    url: pageUrl,",
     "    locals: {},",
     "    cookies: parseCookies(request.headers.get('cookie') || ''),",
+    "    resolveUrl(u) { return new URL(u, pageUrl.href).href; },",
     "  };",
     "  try {",
     "    const result = await action.execute(input, {",
@@ -33827,7 +35103,7 @@ ${compRegEntries.join("\n")}
     ""
   ].join("\n");
   const funcCode = [
-    "import { renderFullPage, renderPageStream, renderPage, compileFile, setVskHydrate, parseCookies, getAction, validateActionInput, issuesToFieldMap, storeDataScriptGlobal, withSsrStore, assertSameOrigin } from '../runtime.js';",
+    "import { renderFullPage, renderPageStream, renderPage, compileFile, setVskHydrate, parseCookies, getAction, validateActionInput, issuesToFieldMap, storeDataScriptGlobal, withSsrStore, assertSameOrigin, VeskRequest } from '../runtime.js';",
     "",
     middlewareCode || "",
     registryCode,
@@ -33859,8 +35135,8 @@ init_actions();
 
 // ../adapter/src/api-function.ts
 init_strip_ts();
-import { readFileSync as readFileSync4 } from "node:fs";
-import { resolve as resolve6 } from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import { resolve as resolve7 } from "node:path";
 function apiRouteName(fullPath) {
   const parts = fullPath.split("/").filter(Boolean);
   return parts.map((s) => s.startsWith(":") ? s.slice(1) || "param" : s).join("_") || "index";
@@ -33868,10 +35144,10 @@ function apiRouteName(fullPath) {
 function generateApiFunction(apiNode, _apiDir, outDir2, options2) {
   const middlewareCode = options2?.middlewareCode || null;
   const name = apiRouteName(apiNode.fullPath);
-  const funcPath = resolve6(outDir2, "server", "api", `${name}.js`);
+  const funcPath = resolve7(outDir2, "server", "api", `${name}.js`);
   const routeFilePath = apiNode.filePath;
   if (!routeFilePath) throw new Error(`api route ${apiNode.fullPath} has no filePath`);
-  let routeSrc = readFileSync4(routeFilePath, "utf-8");
+  let routeSrc = readFileSync5(routeFilePath, "utf-8");
   routeSrc = routeSrc.replace(/from\s+['"]@vesk\/runtime['"]\s*;?/g, "from '../runtime.js';").replace(/from\s+['"]@vesk\/runtime\/(\w+)['"]\s*;?/g, () => {
     return "from '../runtime.js';";
   });
@@ -34039,10 +35315,10 @@ function generateApiFunction(apiNode, _apiDir, outDir2, options2) {
 }
 
 // ../adapter/src/middleware.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 
 // ../compiler/src/router.ts
-import { readdirSync, statSync, existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { readdirSync, statSync as statSync2, existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
 init_parser();
 init_tokens();
 init_scan();
@@ -34125,7 +35401,7 @@ function fallbackExtractMiddleware(src2) {
 function extractMiddleware(sourcePath2) {
   try {
     if (!existsSync6(sourcePath2)) return null;
-    const src2 = readFileSync5(sourcePath2, "utf-8");
+    const src2 = readFileSync6(sourcePath2, "utf-8");
     const parts = extractMiddlewareParts(src2);
     if (!parts) return null;
     return `async function middleware(${parts.params}) {
@@ -34147,7 +35423,7 @@ function compileMiddleware(mwChain, _appDir) {
   const parts = [];
   for (let i = 0; i < mwChain.length; i++) {
     const { sourcePath: sourcePath2 } = mwChain[i];
-    const src2 = readFileSync6(sourcePath2, "utf-8");
+    const src2 = readFileSync7(sourcePath2, "utf-8");
     const extracted = extractMiddlewareBody(src2);
     if (!extracted) continue;
     parts.push(`async function mw_${i}(${extracted.params}) {
@@ -34239,15 +35515,15 @@ ${extracted.body}
 init_esbuild_fallback();
 init_strip_ts();
 init_client_codegen();
-import { readFileSync as readFileSync7, existsSync as existsSync7, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, statSync as statSync2 } from "node:fs";
-import { resolve as resolve7, join as join4, dirname as dirname5, relative as relative2, sep } from "node:path";
+import { readFileSync as readFileSync8, existsSync as existsSync7, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, statSync as statSync3 } from "node:fs";
+import { resolve as resolve8, join as join5, dirname as dirname6, relative as relative2, sep } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 init_vsk_imports();
 init_md_inline();
-var __dirname3 = dirname5(fileURLToPath2(import.meta.url));
+var __dirname3 = dirname6(fileURLToPath2(import.meta.url));
 function fileUnchanged(filePath, cached) {
   try {
-    const st = statSync2(filePath);
+    const st = statSync3(filePath);
     return st.mtimeMs === cached.mtimeMs && st.size === cached.size;
   } catch {
     return false;
@@ -34261,15 +35537,15 @@ function buildRouterOpts(options2) {
   return "";
 }
 function findRuntimeSrc2(appDir) {
-  const monorepoRoot = resolve7(__dirname3, "..", "..", "..");
+  const monorepoRoot = resolve8(__dirname3, "..", "..", "..");
   const candidates = [
-    resolve7(monorepoRoot, "packages", "runtime", "dist"),
-    resolve7(appDir, "..", "node_modules", "@vesk/runtime"),
-    resolve7(appDir, "node_modules", "@vesk/runtime")
+    resolve8(monorepoRoot, "packages", "runtime", "dist"),
+    resolve8(appDir, "..", "node_modules", "@vesk/runtime"),
+    resolve8(appDir, "node_modules", "@vesk/runtime")
   ];
   for (const base of candidates) {
-    for (const dir of [base, join4(base, "dist")]) {
-      if (existsSync7(join4(dir, "index-client.js"))) return dir;
+    for (const dir of [base, join5(base, "dist")]) {
+      if (existsSync7(join5(dir, "index-client.js"))) return dir;
     }
   }
   throw new Error('@vesk/runtime/dist not found \u2014 run "npm run build" first');
@@ -34307,11 +35583,11 @@ async function generateClientBundle(routeTree, appDir, componentMap, options2) {
     return code.replace(/^import\s*\{[^}]*\}\s*from\s*['"][^'"]*\.vsk['"];?\s*\n?/gm, "");
   }
   function resolveVskImports(filePath, compile) {
-    const src2 = readFileSync7(filePath, "utf-8");
+    const src2 = readFileSync8(filePath, "utf-8");
     const resolved = [];
     for (const importPath of collectVskImportPaths(vskImportLines(src2), filePath)) {
       try {
-        readFileSync7(importPath);
+        readFileSync8(importPath);
       } catch {
         continue;
       }
@@ -34351,9 +35627,9 @@ async function generateClientBundle(routeTree, appDir, componentMap, options2) {
       return;
     }
     compiledFiles++;
-    let src2 = readFileSync7(filePath, "utf-8");
+    let src2 = readFileSync8(filePath, "utf-8");
     if (/content=["'][^"']*\.md["']/i.test(src2)) {
-      src2 = inlineMdContentAttrs(src2, dirname5(filePath), guessProjectRoots(appDir));
+      src2 = inlineMdContentAttrs(src2, dirname6(filePath), guessProjectRoots(appDir));
     }
     const namesBefore = cache2 ? new Set(runtimeImportNames) : null;
     const importedPaths = resolveVskImports(filePath, (p, n) => compileFile2(p, n || "", output));
@@ -34374,7 +35650,7 @@ async function generateClientBundle(routeTree, appDir, componentMap, options2) {
       output.push(`Object.defineProperty(__hydrators, ${JSON.stringify(resolvedName)}, { get: () => __hydrators[${JSON.stringify(actualName)}], configurable: true });`);
     }
     if (cache2 && namesBefore) {
-      const st = statSync2(filePath);
+      const st = statSync3(filePath);
       cache2.files.set(filePath, {
         mtimeMs: st.mtimeMs,
         size: st.size,
@@ -34397,31 +35673,31 @@ async function generateClientBundle(routeTree, appDir, componentMap, options2) {
     let walkSplit2 = function(nodes, _chain) {
       for (const node of nodes) {
         const chunkCode = [];
-        const pagePath = resolve7(appDir, node.sourceDir, "page.vsk");
+        const pagePath = resolve8(appDir, node.sourceDir, "page.vsk");
         if (node.page && existsSync7(pagePath)) {
           compileFile2(pagePath, node.page, chunkCode);
         }
-        const layoutPath = resolve7(appDir, node.sourceDir, "layout.vsk");
+        const layoutPath = resolve8(appDir, node.sourceDir, "layout.vsk");
         if (node.layout && existsSync7(layoutPath)) {
           compileFile2(layoutPath, node.layout, chunkCode);
         }
-        const errorPath = resolve7(appDir, node.sourceDir, "error.vsk");
+        const errorPath = resolve8(appDir, node.sourceDir, "error.vsk");
         if (node.error && existsSync7(errorPath)) {
           compileFile2(errorPath, node.error, chunkCode);
         }
-        const notFoundPath = resolve7(appDir, node.sourceDir, "not-found.vsk");
+        const notFoundPath = resolve8(appDir, node.sourceDir, "not-found.vsk");
         if (node.notFound && existsSync7(notFoundPath)) {
           compileFile2(notFoundPath, node.notFound, chunkCode);
         }
-        const offlinePath = resolve7(appDir, node.sourceDir, "offline.vsk");
+        const offlinePath = resolve8(appDir, node.sourceDir, "offline.vsk");
         if (node.offline && existsSync7(offlinePath)) {
           compileFile2(offlinePath, node.offline, chunkCode);
         }
-        const networkPath = resolve7(appDir, node.sourceDir, "network.vsk");
+        const networkPath = resolve8(appDir, node.sourceDir, "network.vsk");
         if (node.network && existsSync7(networkPath)) {
           compileFile2(networkPath, node.network, chunkCode);
         }
-        const loadingPath = resolve7(appDir, node.sourceDir, "loading.vsk");
+        const loadingPath = resolve8(appDir, node.sourceDir, "loading.vsk");
         if (node.loading && existsSync7(loadingPath)) {
           compileFile2(loadingPath, node.loading, chunkCode);
         }
@@ -34478,7 +35754,7 @@ ${entry.code}
     let compileFileMono2 = function(filePath, resolvedName) {
       if (seen.has(filePath)) return;
       seen.add(filePath);
-      const src2 = readFileSync7(filePath, "utf-8");
+      const src2 = readFileSync8(filePath, "utf-8");
       resolveVskImports(filePath, (p, n) => compileFileMono2(p, n || ""));
       const compCode = compileClient(src2, null, { forceClient: true });
       if (compCode) {
@@ -34499,19 +35775,19 @@ ${entry.code}
       }
     }, walkMono2 = function(nodes) {
       for (const node of nodes) {
-        const pagePath = resolve7(appDir, node.sourceDir, "page.vsk");
+        const pagePath = resolve8(appDir, node.sourceDir, "page.vsk");
         if (node.page && existsSync7(pagePath)) compileFileMono2(pagePath, node.page);
-        const layoutPath = resolve7(appDir, node.sourceDir, "layout.vsk");
+        const layoutPath = resolve8(appDir, node.sourceDir, "layout.vsk");
         if (node.layout && existsSync7(layoutPath)) compileFileMono2(layoutPath, node.layout);
-        const errorPath = resolve7(appDir, node.sourceDir, "error.vsk");
+        const errorPath = resolve8(appDir, node.sourceDir, "error.vsk");
         if (node.error && existsSync7(errorPath)) compileFileMono2(errorPath, node.error);
-        const notFoundPath = resolve7(appDir, node.sourceDir, "not-found.vsk");
+        const notFoundPath = resolve8(appDir, node.sourceDir, "not-found.vsk");
         if (node.notFound && existsSync7(notFoundPath)) compileFileMono2(notFoundPath, node.notFound);
-        const offlinePath = resolve7(appDir, node.sourceDir, "offline.vsk");
+        const offlinePath = resolve8(appDir, node.sourceDir, "offline.vsk");
         if (node.offline && existsSync7(offlinePath)) compileFileMono2(offlinePath, node.offline);
-        const networkPath = resolve7(appDir, node.sourceDir, "network.vsk");
+        const networkPath = resolve8(appDir, node.sourceDir, "network.vsk");
         if (node.network && existsSync7(networkPath)) compileFileMono2(networkPath, node.network);
-        const loadingPath = resolve7(appDir, node.sourceDir, "loading.vsk");
+        const loadingPath = resolve8(appDir, node.sourceDir, "loading.vsk");
         if (node.loading && existsSync7(loadingPath)) compileFileMono2(loadingPath, node.loading);
         walkMono2(node.children || []);
       }
@@ -34561,9 +35837,9 @@ function buildRuntimeCode(runtimeDir) {
   ];
   let code = "";
   for (const f of runtimeFiles) {
-    const p = join4(runtimeDir, f);
+    const p = join5(runtimeDir, f);
     if (existsSync7(p)) {
-      let src2 = readFileSync7(p, "utf-8");
+      let src2 = readFileSync8(p, "utf-8");
       src2 = stripTypes(src2);
       src2 = src2.replace(/^import\s+[\s\S]*?from\s+['"](?:\.\/.*?|@vesk\/runtime\/src\/.*?)['"];?\n?/gm, "");
       src2 = src2.replace(/^import\s+['"](?:\.\/.*?|@vesk\/runtime\/src\/.*?)['"];?\n?/gm, "");
@@ -34575,7 +35851,7 @@ ${src2}
 `;
     }
   }
-  const indexSrc = readFileSync7(join4(runtimeDir, "index-client.js"), "utf-8");
+  const indexSrc = readFileSync8(join5(runtimeDir, "index-client.js"), "utf-8");
   const exportNames = stripTypes(indexSrc).match(/export\s*\{\s*([^}]+)\s*\}\s*from/g)?.flatMap((m) => m.replace(/export\s*\{\s*|\s*\}\s*from/g, "").split(",").map((s) => s.trim())) || [];
   code += "// --- exports ---\n";
   for (const name of [...new Set(exportNames)]) {
@@ -34585,7 +35861,7 @@ ${src2}
   return code;
 }
 function runtimeExportNames(runtimeDir) {
-  const indexSrc = readFileSync7(join4(runtimeDir, "index-client.js"), "utf-8");
+  const indexSrc = readFileSync8(join5(runtimeDir, "index-client.js"), "utf-8");
   const names = /* @__PURE__ */ new Set();
   for (const m of indexSrc.matchAll(/export\s*\{([^}]+)\}\s*from/g)) {
     for (const raw2 of m[1].split(",")) {
@@ -34604,7 +35880,7 @@ async function buildTreeShakenRuntime(runtimeDir, usedNames) {
     console.error(`vesk: runtime names not exported \u2014 ${missing.join(", ")}; falling back to full runtime`);
     return buildRuntimeCode(runtimeDir);
   }
-  const entry = join4(runtimeDir, `.runtime-tree-entry-${runtimeEntryId++}.mjs`);
+  const entry = join5(runtimeDir, `.runtime-tree-entry-${runtimeEntryId++}.mjs`);
   try {
     writeFileSync2(entry, `export { ${unique.join(", ")} } from './index-client.js';
 `);
@@ -34776,19 +36052,19 @@ function generateManifest(routes, ssrRoutes, apiRoutes, staticRoutes, middleware
 
 // ../adapter/src/static.ts
 init_paths();
-import { mkdirSync, copyFileSync, readdirSync as readdirSync2, statSync as statSync3, existsSync as existsSync8, writeFileSync as writeFileSync3, readFileSync as readFileSync8 } from "node:fs";
-import { resolve as resolve9, join as join5 } from "node:path";
+import { mkdirSync, copyFileSync, readdirSync as readdirSync2, statSync as statSync5, existsSync as existsSync9, writeFileSync as writeFileSync3, readFileSync as readFileSync10 } from "node:fs";
+import { resolve as resolve10, join as join6 } from "node:path";
 function copyStaticAssets(publicDir, outDir2) {
-  const targetDir = resolve9(outDir2, "static", "public");
+  const targetDir = resolve10(outDir2, "static", "public");
   mkdirSync(targetDir, { recursive: true });
-  if (!existsSync8(publicDir)) return;
+  if (!existsSync9(publicDir)) return;
   function copyDir(src2, dest) {
     mkdirSync(dest, { recursive: true });
     const entries = readdirSync2(src2);
     for (const entry of entries) {
-      const srcPath = join5(src2, entry);
-      const destPath = join5(dest, entry);
-      const st = statSync3(srcPath);
+      const srcPath = join6(src2, entry);
+      const destPath = join6(dest, entry);
+      const st = statSync5(srcPath);
       if (st.isDirectory()) {
         copyDir(srcPath, destPath);
       } else {
@@ -34800,15 +36076,15 @@ function copyStaticAssets(publicDir, outDir2) {
 }
 
 // ../adapter/src/prod-server.ts
-import { readFileSync as readFileSync9, existsSync as existsSync9, statSync as statSync4 } from "node:fs";
-import { resolve as resolve10, extname as extname2, dirname as dirname6 } from "node:path";
+import { readFileSync as readFileSync11, existsSync as existsSync10, statSync as statSync6 } from "node:fs";
+import { resolve as resolve11, extname as extname3, dirname as dirname7 } from "node:path";
 import { createServer } from "node:http";
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 init_server_utils();
 init_paths();
-var _require = createRequire(import.meta.url);
-var __dirname4 = dirname6(fileURLToPath3(import.meta.url));
+var _require = createRequire2(import.meta.url);
+var __dirname4 = dirname7(fileURLToPath3(import.meta.url));
 async function readBody(req, maxBytes = DEFAULT_MAX_BODY_BYTES) {
   const chunks = [];
   let total = 0;
@@ -34819,6 +36095,24 @@ async function readBody(req, maxBytes = DEFAULT_MAX_BODY_BYTES) {
   }
   return Buffer.concat(chunks);
 }
+async function deliverResponse(res, response) {
+  res.writeHead(response.status, Object.fromEntries(response.headers));
+  const body = response.body;
+  if (body && typeof body.getReader === "function") {
+    const reader = body.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        res.write(Buffer.from(value));
+      }
+    } catch {
+    }
+    res.end();
+    return;
+  }
+  res.end(await response.text());
+}
 function bodyTooLarge(maxBytes) {
   const err = new Error(`Request body exceeds limit (${maxBytes} bytes)`);
   err.status = 413;
@@ -34897,27 +36191,28 @@ async function startProdServer(outDir, options) {
   const host = options?.host || "127.0.0.1";
   const maxBodyBytes = options?.maxBodyBytes || DEFAULT_MAX_BODY_BYTES;
   if (!process.env.NODE_ENV) process.env.NODE_ENV = "production";
-  const staticDir = resolve10(outDir, "static");
-  const configPath = resolve10(outDir, "config.json");
-  if (!existsSync9(configPath)) {
+  const staticDir = resolve11(outDir, "static");
+  const configPath = resolve11(outDir, "config.json");
+  installMdReadHook([resolve11(staticDir, "public")]);
+  if (!existsSync10(configPath)) {
     console.error(`vesk start: no build found at ${outDir}`);
     console.error('Run "vesk build" first');
     process.exit(1);
   }
-  const buildConfig = JSON.parse(readFileSync9(configPath, "utf-8"));
+  const buildConfig = JSON.parse(readFileSync11(configPath, "utf-8"));
   console.error(`vesk start: serving from ${outDir}`);
-  const projectDir = resolve10(outDir, "..");
+  const projectDir = resolve11(outDir, "..");
   let securityConfig = {};
   let mdConfig;
   try {
-    const veskConfigPath = resolve10(projectDir, "vesk.config.js");
-    const veskConfigTsPath = resolve10(projectDir, "vesk.config.ts");
+    const veskConfigPath = resolve11(projectDir, "vesk.config.js");
+    const veskConfigTsPath = resolve11(projectDir, "vesk.config.ts");
     let rawConfig = {};
-    if (existsSync9(veskConfigPath)) {
+    if (existsSync10(veskConfigPath)) {
       rawConfig = _require(veskConfigPath);
-    } else if (existsSync9(veskConfigTsPath)) {
+    } else if (existsSync10(veskConfigTsPath)) {
       const { transpile } = _require("typescript");
-      const src = readFileSync9(veskConfigTsPath, "utf-8");
+      const src = readFileSync11(veskConfigTsPath, "utf-8");
       const result = transpile(src, { module: 99, target: 99 });
       rawConfig = eval(`(${result})`);
     }
@@ -34946,8 +36241,8 @@ async function startProdServer(outDir, options) {
   } catch {
   }
   let middlewareMod = null;
-  const mwPath = resolve10(outDir, "server", "middleware.js");
-  if (existsSync9(mwPath)) {
+  const mwPath = resolve11(outDir, "server", "middleware.js");
+  if (existsSync10(mwPath)) {
     try {
       middlewareMod = await import(`${mwPath}?t=${Date.now()}`);
     } catch {
@@ -34956,8 +36251,8 @@ async function startProdServer(outDir, options) {
   const functionCache = /* @__PURE__ */ new Map();
   async function loadFunction(funcPath) {
     if (functionCache.has(funcPath)) return functionCache.get(funcPath);
-    const fullPath = resolve10(outDir, funcPath);
-    if (!existsSync9(fullPath)) return null;
+    const fullPath = resolve11(outDir, funcPath);
+    if (!existsSync10(fullPath)) return null;
     try {
       const mod = await import(`${fullPath}?t=${Date.now()}`);
       functionCache.set(funcPath, mod);
@@ -35017,12 +36312,12 @@ async function startProdServer(outDir, options) {
       }
       return origWriteHead(statusCode, headers2);
     });
-    const publicDir = resolve10(staticDir, "public");
+    const publicDir = resolve11(staticDir, "public");
     const rootFile = url.pathname.length > 1 ? resolveWithin(publicDir, url.pathname.slice(1)) : null;
-    if (rootFile && existsSync9(rootFile) && statSync4(rootFile).isFile()) {
-      const ext = extname2(rootFile);
+    if (rootFile && existsSync10(rootFile) && statSync6(rootFile).isFile()) {
+      const ext = extname3(rootFile);
       res.writeHead(200, { "Content-Type": MIME[ext] || "application/octet-stream" });
-      res.end(readFileSync9(rootFile));
+      res.end(readFileSync11(rootFile));
       return;
     }
     if (url.pathname === "/ssr-data.js") {
@@ -35038,10 +36333,10 @@ async function startProdServer(outDir, options) {
       return;
     }
     if (url.pathname === "/_vesk/runtime.js") {
-      const clientPath = resolve10(staticDir, "client.js");
-      if (existsSync9(clientPath)) {
+      const clientPath = resolve11(staticDir, "client.js");
+      if (existsSync10(clientPath)) {
         res.writeHead(200, { "Content-Type": "application/javascript" });
-        res.end(readFileSync9(clientPath));
+        res.end(readFileSync11(clientPath));
         return;
       }
     }
@@ -35053,20 +36348,20 @@ async function startProdServer(outDir, options) {
         res.end("Forbidden");
         return;
       }
-      if (existsSync9(staticPath) && statSync4(staticPath).isFile()) {
-        const ext = extname2(staticPath);
+      if (existsSync10(staticPath) && statSync6(staticPath).isFile()) {
+        const ext = extname3(staticPath);
         res.writeHead(200, { "Content-Type": MIME[ext] || "application/octet-stream" });
-        res.end(readFileSync9(staticPath));
+        res.end(readFileSync11(staticPath));
         return;
       }
     }
     if (buildConfig.prerendered) {
       const prerendered = buildConfig.prerendered.find((r) => r.path === url.pathname);
       if (prerendered) {
-        const htmlPath = resolve10(outDir, prerendered.file);
-        if (existsSync9(htmlPath)) {
+        const htmlPath = resolve11(outDir, prerendered.file);
+        if (existsSync10(htmlPath)) {
           res.writeHead(200, { "Content-Type": "text/html" });
-          res.end(readFileSync9(htmlPath));
+          res.end(readFileSync11(htmlPath));
           return;
         }
       }
@@ -35128,9 +36423,7 @@ async function startProdServer(outDir, options) {
       try {
         const webRequest = makeWebRequest(req, url.href, maxBodyBytes);
         const response = await mod.handleAction(webRequest, actionId);
-        const body = await response.text();
-        res.writeHead(response.status, Object.fromEntries(response.headers));
-        res.end(body);
+        await deliverResponse(res, response);
       } catch (e) {
         const status = errorStatus(e, 500);
         const message = status === 500 && process.env.NODE_ENV === "production" ? "Internal Server Error" : e instanceof Error ? e.message : String(e);
@@ -35149,9 +36442,7 @@ async function startProdServer(outDir, options) {
               try {
                 const webRequest = makeWebRequest(req, url.href, maxBodyBytes);
                 const response = await mod.handle(webRequest);
-                const body = await response.text();
-                res.writeHead(response.status, Object.fromEntries(response.headers));
-                res.end(body);
+                await deliverResponse(res, response);
                 return;
               } catch (e) {
                 const status = errorStatus(e, 500);
@@ -35164,14 +36455,14 @@ async function startProdServer(outDir, options) {
         }
       }
     }
-    const appDir = resolve10(projectDir, "app");
-    const nfPath = resolve10(appDir, "not-found.vsk");
+    const appDir = resolve11(projectDir, "app");
+    const nfPath = resolve11(appDir, "not-found.vsk");
     let notFoundHtml = null;
-    if (existsSync9(nfPath)) {
+    if (existsSync10(nfPath)) {
       try {
-        const runtimePath = resolve10(outDir, "server", "runtime.js");
+        const runtimePath = resolve11(outDir, "server", "runtime.js");
         const { renderFullPage: renderFullPage2, storeDataScriptGlobal } = await import(runtimePath);
-        const src2 = readFileSync9(nfPath, "utf-8");
+        const src2 = readFileSync11(nfPath, "utf-8");
         const compName = resolveComponentName(src2) || "NotFound";
         notFoundHtml = await renderFullPage2(src2, compName, { params: {}, url: url.pathname }, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: ["/_vesk/static/_tailwind.css", "/_vesk/static/global.css"], security: securityConfig?.security || {}, externalDataScript: storeDataScriptGlobal, sourcePath: nfPath });
       } catch {
@@ -35229,13 +36520,13 @@ async function startProdServer(outDir, options) {
                 return;
               }
               console.error("vesk ssr error:", err.message);
-              const errPath = resolve10(appDir, "error.vsk");
+              const errPath = resolve11(appDir, "error.vsk");
               let errorHtml = null;
-              if (existsSync9(errPath)) {
+              if (existsSync10(errPath)) {
                 try {
-                  const runtimePath = resolve10(outDir, "server", "runtime.js");
+                  const runtimePath = resolve11(outDir, "server", "runtime.js");
                   const { renderFullPage: renderFullPage2, storeDataScriptGlobal } = await import(runtimePath);
-                  const src2 = readFileSync9(errPath, "utf-8");
+                  const src2 = readFileSync11(errPath, "utf-8");
                   const compName = resolveComponentName(src2) || "Error";
                   const expose = process.env.NODE_ENV !== "production";
                   errorHtml = await renderFullPage2(src2, compName, { error: expose ? err.message : "Internal Server Error", stack: expose ? err.stack : "", statusCode: 500, url: url.pathname }, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: ["/_vesk/static/_tailwind.css", "/_vesk/static/global.css"], clientScriptUrl: "/_vesk/static/client.js", security: securityConfig?.security || {}, externalDataScript: storeDataScriptGlobal, sourcePath: errPath });
@@ -35260,22 +36551,22 @@ async function startProdServer(outDir, options) {
 }
 
 // ../adapter/dist/index.js
-var __dirname6 = dirname11(fileURLToPath5(import.meta.url));
+var __dirname6 = dirname12(fileURLToPath5(import.meta.url));
 async function resolveCompilerApi(name) {
-  const monorepoSrc = resolve17(__dirname6, "..", "..", "compiler", "src");
-  if (existsSync15(monorepoSrc)) {
-    const tsFile = resolve17(monorepoSrc, name.replace(/\.js$/, ".ts"));
-    if (existsSync15(tsFile)) {
+  const monorepoSrc = resolve18(__dirname6, "..", "..", "compiler", "src");
+  if (existsSync16(monorepoSrc)) {
+    const tsFile = resolve18(monorepoSrc, name.replace(/\.js$/, ".ts"));
+    if (existsSync16(tsFile)) {
       return import(tsFile);
     }
-    return import(resolve17(monorepoSrc, name));
+    return import(resolve18(monorepoSrc, name));
   }
   return import(`@vesk/compiler/src/${name.replace(/\.js$/, "")}`);
 }
 async function build2(appDir, options2) {
-  appDir = resolve17(appDir);
-  const outDir2 = resolve17(options2?.outDir || resolve17(appDir, "..", ".vesk"));
-  const publicDir = options2?.publicDir || resolve17(appDir, "..", "public");
+  appDir = resolve18(appDir);
+  const outDir2 = resolve18(options2?.outDir || resolve18(appDir, "..", ".vesk"));
+  const publicDir = options2?.publicDir || resolve18(appDir, "..", "public");
   const plugins = options2?.plugins || [];
   if (options2?.md) {
     const { configureMd: configureMd3 } = await Promise.resolve().then(() => (init_md(), md_exports));
@@ -35288,10 +36579,10 @@ async function build2(appDir, options2) {
   }
   console.error(`vesk build: output \u2192 ${outDir2}`);
   const dirs = [
-    resolve17(outDir2, "server", "functions"),
-    resolve17(outDir2, "server", "api"),
-    resolve17(outDir2, "static", "public"),
-    resolve17(outDir2, "prerendered")
+    resolve18(outDir2, "server", "functions"),
+    resolve18(outDir2, "server", "api"),
+    resolve18(outDir2, "static", "public"),
+    resolve18(outDir2, "prerendered")
   ];
   for (const d of dirs)
     mkdirSync6(d, { recursive: true });
@@ -35303,14 +36594,14 @@ async function build2(appDir, options2) {
     console.error("vesk build: no routes found in", appDir);
     return;
   }
-  const projectRoot = resolve17(appDir, "..");
-  const componentsDir = resolve17(projectRoot, "components");
+  const projectRoot = resolve18(appDir, "..");
+  const componentsDir = resolve18(projectRoot, "components");
   const componentMap = scanComponents(componentsDir);
   if (componentMap.size > 0) {
     console.error(`vesk build: ${componentMap.size} external components found in ${componentsDir}`);
   }
-  const apiDir = resolve17(appDir, "api");
-  const apiTree = existsSync15(apiDir) ? scanApiRoutes2(apiDir) : [];
+  const apiDir = resolve18(appDir, "api");
+  const apiTree = existsSync16(apiDir) ? scanApiRoutes2(apiDir) : [];
   console.error(`vesk build: ${routeTree.length} root routes, ${apiTree.length} API routes`);
   console.error("vesk build: bundling server runtime...");
   await bundleRuntime(appDir, outDir2);
@@ -35323,21 +36614,21 @@ async function build2(appDir, options2) {
         const mwChain2 = collectMiddlewareChain2(routeTree, node.fullPath, appDir);
         let mwCode = null;
         if (mwChain2.length > 0) {
-          const mwSources = mwChain2.map((m) => readFileSync14(m.sourcePath, "utf-8"));
+          const mwSources = mwChain2.map((m) => readFileSync16(m.sourcePath, "utf-8"));
           mwCode = compileMiddlewareCode(mwSources);
         }
         const { funcPath, funcCode, name } = generateSsrFunction(node, appDir, outDir2, componentMap, { ancestorLayouts, middlewareCode: mwCode });
         writeFileSync8(funcPath, funcCode, "utf-8");
-        const pagePath = resolve17(appDir, node.sourceDir, "page.vsk");
-        if (existsSync15(pagePath)) {
-          const src2 = readFileSync14(pagePath, "utf-8");
+        const pagePath = resolve18(appDir, node.sourceDir, "page.vsk");
+        if (existsSync16(pagePath)) {
+          const src2 = readFileSync16(pagePath, "utf-8");
           const actionIds = collectActionIds(src2);
           if (node.layout) {
-            const layoutSrc = readFileSync14(resolve17(appDir, node.sourceDir, "layout.vsk"), "utf-8");
+            const layoutSrc = readFileSync16(resolve18(appDir, node.sourceDir, "layout.vsk"), "utf-8");
             actionIds.push(...collectActionIds(layoutSrc));
           }
           for (const a of ancestorLayouts) {
-            const ancestorSrc = readFileSync14(resolve17(appDir, a.sourceDir, "layout.vsk"), "utf-8");
+            const ancestorSrc = readFileSync16(resolve18(appDir, a.sourceDir, "layout.vsk"), "utf-8");
             actionIds.push(...collectActionIds(ancestorSrc));
           }
           for (const id of actionIds) {
@@ -35377,7 +36668,7 @@ async function build2(appDir, options2) {
   if (mwChain.length > 0) {
     const mwCode = compileMiddleware(mwChain, appDir);
     if (mwCode) {
-      writeFileSync8(resolve17(outDir2, "server", "middleware.js"), mwCode, "utf-8");
+      writeFileSync8(resolve18(outDir2, "server", "middleware.js"), mwCode, "utf-8");
       middlewareEnabled = true;
       console.error(`vesk build: mw   \u2192 server/middleware.js  (${mwChain.length} middlewares)`);
     }
@@ -35391,28 +36682,28 @@ async function build2(appDir, options2) {
   if (options2?.routeDataCache !== void 0)
     bundleOpts.routeDataCache = options2.routeDataCache;
   const { main, chunks } = await generateClientBundle(routeTree, appDir, componentMap, bundleOpts);
-  writeFileSync8(resolve17(outDir2, "static", "client.js"), main, "utf-8");
+  writeFileSync8(resolve18(outDir2, "static", "client.js"), main, "utf-8");
   const mode = chunks.length > 0 ? "code-split" : "monolithic";
   console.error(`vesk build: client \u2192 static/client.js  (${main.length} bytes, ${mode})`);
   if (chunks.length > 0) {
-    const staticDir2 = resolve17(outDir2, "static");
+    const staticDir2 = resolve18(outDir2, "static");
     for (const chunk of chunks) {
-      writeFileSync8(resolve17(staticDir2, chunk.name), chunk.code, "utf-8");
+      writeFileSync8(resolve18(staticDir2, chunk.name), chunk.code, "utf-8");
       console.error(`vesk build: chunk \u2192 static/${chunk.name}  (${chunk.code.length} bytes)`);
     }
   }
   copyStaticAssets(publicDir, outDir2);
   console.error("vesk build: static \u2192 static/public/");
-  const srcDir = resolve17(appDir, "..", "src");
-  const cssSrc = resolve17(srcDir, "global.css");
-  const altCssSrc = resolve17(srcDir, "app.css");
+  const srcDir = resolve18(appDir, "..", "src");
+  const cssSrc = resolve18(srcDir, "global.css");
+  const altCssSrc = resolve18(srcDir, "app.css");
   let cssContent = null;
   let cssSourcePath = null;
-  if (existsSync15(cssSrc)) {
-    cssContent = readFileSync14(cssSrc, "utf-8");
+  if (existsSync16(cssSrc)) {
+    cssContent = readFileSync16(cssSrc, "utf-8");
     cssSourcePath = cssSrc;
-  } else if (existsSync15(altCssSrc)) {
-    cssContent = readFileSync14(altCssSrc, "utf-8");
+  } else if (existsSync16(altCssSrc)) {
+    cssContent = readFileSync16(altCssSrc, "utf-8");
     cssSourcePath = altCssSrc;
   }
   function stripTailwindDirectives2(css) {
@@ -35436,7 +36727,7 @@ async function build2(appDir, options2) {
   }
   if (cssContent !== null) {
     const userCss = stripTailwindDirectives2(cssContent);
-    const userCssTarget = resolve17(outDir2, "static", "global.css");
+    const userCssTarget = resolve18(outDir2, "static", "global.css");
     writeFileSync8(userCssTarget, userCss, "utf-8");
     console.error(`vesk build: css  \u2192 static/global.css  (${userCss.length} bytes)`);
     let twCss = cssContent;
@@ -35448,7 +36739,7 @@ async function build2(appDir, options2) {
         }
       }
     }
-    const twCssTarget = resolve17(outDir2, "static", "_tailwind.css");
+    const twCssTarget = resolve18(outDir2, "static", "_tailwind.css");
     const hasUnresolvedTailwindImport = /@import\s+['"]tailwindcss['"]/.test(twCss);
     if (hasUnresolvedTailwindImport) {
       const lines = twCss.split("\n").filter((l) => !/^\s*@import\s+['"]tailwindcss['"]/.test(l));
@@ -35488,23 +36779,23 @@ async function build2(appDir, options2) {
   }
   {
     const { generateSitemap: generateSitemap2, generateRobotsTxt: generateRobotsTxt2 } = await Promise.resolve().then(() => (init_static(), static_exports));
-    const publicDirResolved = resolve17(outDir2, "static", "public");
+    const publicDirResolved = resolve18(outDir2, "static", "public");
     const siteUrl = options2?.siteUrl || "http://localhost:3000";
-    const sitemapOverride = resolve17(publicDirResolved, "sitemap.xml");
-    if (!existsSync15(sitemapOverride)) {
+    const sitemapOverride = resolve18(publicDirResolved, "sitemap.xml");
+    if (!existsSync16(sitemapOverride)) {
       const sitemap = generateSitemap2(routeTree, ssrRoutes, prerenderedRoutes, { siteUrl });
       writeFileSync8(sitemapOverride, sitemap, "utf-8");
       console.error(`vesk build: seo   \u2192 static/public/sitemap.xml (${sitemap.length} bytes)`);
     }
-    const robotsOverride = resolve17(publicDirResolved, "robots.txt");
-    if (!existsSync15(robotsOverride)) {
+    const robotsOverride = resolve18(publicDirResolved, "robots.txt");
+    if (!existsSync16(robotsOverride)) {
       const robots = generateRobotsTxt2(siteUrl);
       writeFileSync8(robotsOverride, robots, "utf-8");
       console.error(`vesk build: seo   \u2192 static/public/robots.txt (${robots.length} bytes)`);
     }
   }
   const manifest = generateManifest(routeTree, ssrRoutes, apiRoutes, prerenderedRoutes, middlewareEnabled, actionMap);
-  writeFileSync8(resolve17(outDir2, "config.json"), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  writeFileSync8(resolve18(outDir2, "config.json"), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
   console.error("vesk build: config \u2192 config.json");
   {
     const { detectPlatform: detectPlatform2 } = await Promise.resolve().then(() => (init_platform(), platform_exports));
@@ -35543,16 +36834,16 @@ vesk build: done (${outDir2})`);
 init_seo_audit();
 
 // src/dev-server.ts
-import { readFileSync as readFileSync19, watch, statSync as statSync13, existsSync as existsSync22, readdirSync as readdirSync11 } from "node:fs";
-import { resolve as resolve23, extname as extname5, join as join12 } from "node:path";
+import { readFileSync as readFileSync22, watch, statSync as statSync16, existsSync as existsSync24, readdirSync as readdirSync11 } from "node:fs";
+import { resolve as resolve24, extname as extname6, join as join13 } from "node:path";
 import { createServer as createServer2 } from "node:http";
 import { WebSocketServer } from "ws";
 
 // ../compiler/dist/strip-ts.js
 init_parser();
 import { walk as walk4 } from "zimmerframe";
-import { print as print5 } from "esrap";
-import ts5 from "esrap/languages/ts";
+import { print as print6 } from "esrap";
+import ts6 from "esrap/languages/ts";
 var TS_NODE_TYPES2 = /* @__PURE__ */ new Set([
   "TSAsExpression",
   "TSSatisfiesExpression",
@@ -35693,7 +36984,7 @@ function stripCodeTypes2(code) {
     stripped.body = stripped.body.filter((n) => !isTypeOnlyStatement2(n));
   }
   try {
-    return print5(stripped, ts5()).code;
+    return print6(stripped, ts6()).code;
   } catch {
     return code;
   }
@@ -35742,12 +37033,13 @@ init_parser();
 init_ir_generator();
 init_actions();
 init_server_utils();
+init_module_imports();
 init_scan();
 init_md_inline();
 init_strip_ts();
 import { walk as walk5 } from "zimmerframe";
-import { print as print6 } from "esrap";
-import ts6 from "esrap/languages/ts";
+import { print as print7 } from "esrap";
+import ts7 from "esrap/languages/ts";
 import tsx2 from "esrap/languages/tsx";
 function callExpr2(callee, args2 = []) {
   return { type: "CallExpression", callee, arguments: args2, optional: false };
@@ -35792,7 +37084,7 @@ function containsJsx2(node, depth = 0) {
   return false;
 }
 function printAst2(ast) {
-  return print6(ast, containsJsx2(ast) ? tsx2() : ts6()).code;
+  return print7(ast, containsJsx2(ast) ? tsx2() : ts7()).code;
 }
 function transformTracked2(irNode, tracked2) {
   const ast = irNode.ast;
@@ -35878,7 +37170,7 @@ function transformTracked2(irNode, tracked2) {
       return context.next();
     }
   });
-  return print6(transformed, containsJsx2(transformed) ? tsx2() : ts6()).code;
+  return print7(transformed, containsJsx2(transformed) ? tsx2() : ts7()).code;
 }
 function collectTrackedNames2(body) {
   const names = /* @__PURE__ */ new Map();
@@ -37201,7 +38493,13 @@ function emitClientFromIR2(ir, options2) {
       runtimeNames.push(name);
     }
   }
-  const runtimeImport = `import { ${runtimeNames.join(", ")} } from '@vesk/runtime';`;
+  const boundLocally = /* @__PURE__ */ new Set();
+  for (const imp of ir.imports) {
+    for (const pair of importBindingPairs(imp))
+      boundLocally.add(pair.local);
+  }
+  const shadowedRuntimeNames = runtimeNames.filter((n) => !boundLocally.has(n));
+  const runtimeImport = `import { ${shadowedRuntimeNames.length > 0 ? shadowedRuntimeNames.join(", ") : "destroy_block"} } from '@vesk/runtime';`;
   const moduleCode = `
 ${runtimeImport}
 ${importLines}
@@ -37225,8 +38523,8 @@ init_parser();
 init_tokens();
 init_scan();
 init_strip_ts();
-import { readdirSync as readdirSync7, statSync as statSync9, existsSync as existsSync16, readFileSync as readFileSync15 } from "fs";
-import { join as join8, relative as relative5, basename } from "path";
+import { readdirSync as readdirSync7, statSync as statSync11, existsSync as existsSync17, readFileSync as readFileSync17 } from "fs";
+import { join as join9, relative as relative5, basename } from "path";
 function collapseSlashes2(p) {
   let out = "";
   let prevSlash = false;
@@ -37243,7 +38541,7 @@ function collapseSlashes2(p) {
   return out;
 }
 function scanRoutes(appDir, options2 = {}) {
-  if (!existsSync16(appDir)) {
+  if (!existsSync17(appDir)) {
     return [];
   }
   return scanDirectory(appDir, appDir, "/", options2);
@@ -37346,10 +38644,10 @@ function scanDirectory(rootDir, dir, parentPath, options2) {
     segmentCount: isGroup || dir === rootDir ? 0 : 1
   };
   for (const entry of entries) {
-    const entryPath = join8(dir, entry);
+    const entryPath = join9(dir, entry);
     let entryStat;
     try {
-      entryStat = statSync9(entryPath);
+      entryStat = statSync11(entryPath);
     } catch {
       continue;
     }
@@ -37398,19 +38696,19 @@ function collectSources(tree) {
   function walk6(nodes) {
     for (const node of nodes) {
       if (node.page)
-        map.set(node.page, join8(node.sourceDir, "page.vsk"));
+        map.set(node.page, join9(node.sourceDir, "page.vsk"));
       if (node.layout)
-        map.set(node.layout, join8(node.sourceDir, "layout.vsk"));
+        map.set(node.layout, join9(node.sourceDir, "layout.vsk"));
       if (node.loading)
-        map.set(node.loading, join8(node.sourceDir, "loading.vsk"));
+        map.set(node.loading, join9(node.sourceDir, "loading.vsk"));
       if (node.error)
-        map.set(node.error, join8(node.sourceDir, "error.vsk"));
+        map.set(node.error, join9(node.sourceDir, "error.vsk"));
       if (node.notFound)
-        map.set(node.notFound, join8(node.sourceDir, "not-found.vsk"));
+        map.set(node.notFound, join9(node.sourceDir, "not-found.vsk"));
       if (node.offline)
-        map.set(node.offline, join8(node.sourceDir, "offline.vsk"));
+        map.set(node.offline, join9(node.sourceDir, "offline.vsk"));
       if (node.network)
-        map.set(node.network, join8(node.sourceDir, "network.vsk"));
+        map.set(node.network, join9(node.sourceDir, "network.vsk"));
       walk6(node.children);
     }
   }
@@ -37496,15 +38794,15 @@ function matchUrl(tree, pathname) {
 }
 
 // ../compiler/dist/api-routes.js
-import { readdirSync as readdirSync8, statSync as statSync10, existsSync as existsSync17 } from "fs";
-import { join as join9 } from "path";
+import { readdirSync as readdirSync8, statSync as statSync12, existsSync as existsSync18 } from "fs";
+import { join as join10 } from "path";
 init_server_utils();
 function basename2(p) {
   const idx = p.lastIndexOf("/");
   return idx === -1 ? p : p.slice(idx + 1);
 }
 function scanApiRoutes(apiDir) {
-  if (!existsSync17(apiDir))
+  if (!existsSync18(apiDir))
     return [];
   return scanApiDir(apiDir, apiDir, "/");
 }
@@ -37534,10 +38832,10 @@ function scanApiDir(rootDir, dir, parentPath) {
     return nodes;
   if (isRouteGroup) {
     for (const entry of entries) {
-      const entryPath = join9(dir, entry);
+      const entryPath = join10(dir, entry);
       let entryStat;
       try {
-        entryStat = statSync10(entryPath);
+        entryStat = statSync12(entryPath);
       } catch {
         continue;
       }
@@ -37564,14 +38862,14 @@ function scanApiDir(rootDir, dir, parentPath) {
     fullPath: collapseSlashes(fullPath) || "/",
     isDynamic,
     isCatchAll,
-    filePath: hasRoute && routeFileName ? join9(dir, routeFileName) : null,
+    filePath: hasRoute && routeFileName ? join10(dir, routeFileName) : null,
     children: []
   };
   for (const entry of entries) {
-    const entryPath = join9(dir, entry);
+    const entryPath = join10(dir, entry);
     let entryStat;
     try {
-      entryStat = statSync10(entryPath);
+      entryStat = statSync12(entryPath);
     } catch {
       continue;
     }
@@ -37869,8 +39167,8 @@ async function executeRewrite(url, originalRequest) {
 }
 
 // ../compiler/dist/middleware.js
-import { existsSync as existsSync18 } from "fs";
-import { resolve as resolve18 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { resolve as resolve19 } from "path";
 
 // ../compiler/src/api-routes.ts
 init_server_utils();
@@ -37929,8 +39227,8 @@ function collectMiddlewareChain(routeTree, url, appDir) {
   }
   function collectForNode(node) {
     if (node.hasMiddleware) {
-      const mwPath2 = resolve18(appDir, node.sourceDir, "middleware.ts");
-      if (existsSync18(mwPath2)) {
+      const mwPath2 = resolve19(appDir, node.sourceDir, "middleware.ts");
+      if (existsSync19(mwPath2)) {
         chain.push({ sourcePath: mwPath2, node });
       }
     }
@@ -38093,8 +39391,8 @@ async function executeMiddlewareChain(chain, request, params, options2 = {}) {
 }
 
 // ../adapter/dist/client-bundle.js
-import { readFileSync as readFileSync16, existsSync as existsSync19, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, statSync as statSync11 } from "node:fs";
-import { resolve as resolve19, join as join10, dirname as dirname12, relative as relative6, sep as sep3 } from "node:path";
+import { readFileSync as readFileSync18, existsSync as existsSync20, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, statSync as statSync13 } from "node:fs";
+import { resolve as resolve20, join as join11, dirname as dirname13, relative as relative6, sep as sep3 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // ../adapter/dist/esbuild-fallback.js
@@ -38149,10 +39447,10 @@ init_strip_ts();
 init_client_codegen();
 init_vsk_imports();
 init_md_inline();
-var __dirname7 = dirname12(fileURLToPath6(import.meta.url));
+var __dirname7 = dirname13(fileURLToPath6(import.meta.url));
 function fileUnchanged2(filePath, cached) {
   try {
-    const st = statSync11(filePath);
+    const st = statSync13(filePath);
     return st.mtimeMs === cached.mtimeMs && st.size === cached.size;
   } catch {
     return false;
@@ -38166,15 +39464,15 @@ function buildRouterOpts2(options2) {
   return "";
 }
 function findRuntimeSrc3(appDir) {
-  const monorepoRoot = resolve19(__dirname7, "..", "..", "..");
+  const monorepoRoot = resolve20(__dirname7, "..", "..", "..");
   const candidates = [
-    resolve19(monorepoRoot, "packages", "runtime", "dist"),
-    resolve19(appDir, "..", "node_modules", "@vesk/runtime"),
-    resolve19(appDir, "node_modules", "@vesk/runtime")
+    resolve20(monorepoRoot, "packages", "runtime", "dist"),
+    resolve20(appDir, "..", "node_modules", "@vesk/runtime"),
+    resolve20(appDir, "node_modules", "@vesk/runtime")
   ];
   for (const base of candidates) {
-    for (const dir of [base, join10(base, "dist")]) {
-      if (existsSync19(join10(dir, "index-client.js")))
+    for (const dir of [base, join11(base, "dist")]) {
+      if (existsSync20(join11(dir, "index-client.js")))
         return dir;
     }
   }
@@ -38214,11 +39512,11 @@ async function generateClientBundle2(routeTree, appDir, componentMap, options2)
     return code.replace(/^import\s*\{[^}]*\}\s*from\s*['"][^'"]*\.vsk['"];?\s*\n?/gm, "");
   }
   function resolveVskImports(filePath, compile) {
-    const src2 = readFileSync16(filePath, "utf-8");
+    const src2 = readFileSync18(filePath, "utf-8");
     const resolved = [];
     for (const importPath of collectVskImportPaths(vskImportLines(src2), filePath)) {
       try {
-        readFileSync16(importPath);
+        readFileSync18(importPath);
       } catch {
         continue;
       }
@@ -38263,9 +39561,9 @@ async function generateClientBundle2(routeTree, appDir, componentMap, options2)
       return;
     }
     compiledFiles++;
-    let src2 = readFileSync16(filePath, "utf-8");
+    let src2 = readFileSync18(filePath, "utf-8");
     if (/content=["'][^"']*\.md["']/i.test(src2)) {
-      src2 = inlineMdContentAttrs(src2, dirname12(filePath), guessProjectRoots(appDir));
+      src2 = inlineMdContentAttrs(src2, dirname13(filePath), guessProjectRoots(appDir));
     }
     const namesBefore = cache2 ? new Set(runtimeImportNames) : null;
     const importedPaths = resolveVskImports(filePath, (p, n) => compileFile2(p, n || "", output));
@@ -38290,7 +39588,7 @@ async function generateClientBundle2(routeTree, appDir, componentMap, options2)
       output.push(`Object.defineProperty(__hydrators, ${JSON.stringify(resolvedName)}, { get: () => __hydrators[${JSON.stringify(actualName)}], configurable: true });`);
     }
     if (cache2 && namesBefore) {
-      const st = statSync11(filePath);
+      const st = statSync13(filePath);
       cache2.files.set(filePath, {
         mtimeMs: st.mtimeMs,
         size: st.size,
@@ -38313,32 +39611,32 @@ async function generateClientBundle2(routeTree, appDir, componentMap, options2)
     let walkSplit2 = function(nodes, _chain) {
       for (const node of nodes) {
         const chunkCode = [];
-        const pagePath = resolve19(appDir, node.sourceDir, "page.vsk");
-        if (node.page && existsSync19(pagePath)) {
+        const pagePath = resolve20(appDir, node.sourceDir, "page.vsk");
+        if (node.page && existsSync20(pagePath)) {
           compileFile2(pagePath, node.page, chunkCode);
         }
-        const layoutPath = resolve19(appDir, node.sourceDir, "layout.vsk");
-        if (node.layout && existsSync19(layoutPath)) {
+        const layoutPath = resolve20(appDir, node.sourceDir, "layout.vsk");
+        if (node.layout && existsSync20(layoutPath)) {
           compileFile2(layoutPath, node.layout, chunkCode);
         }
-        const errorPath = resolve19(appDir, node.sourceDir, "error.vsk");
-        if (node.error && existsSync19(errorPath)) {
+        const errorPath = resolve20(appDir, node.sourceDir, "error.vsk");
+        if (node.error && existsSync20(errorPath)) {
           compileFile2(errorPath, node.error, chunkCode);
         }
-        const notFoundPath = resolve19(appDir, node.sourceDir, "not-found.vsk");
-        if (node.notFound && existsSync19(notFoundPath)) {
+        const notFoundPath = resolve20(appDir, node.sourceDir, "not-found.vsk");
+        if (node.notFound && existsSync20(notFoundPath)) {
           compileFile2(notFoundPath, node.notFound, chunkCode);
         }
-        const offlinePath = resolve19(appDir, node.sourceDir, "offline.vsk");
-        if (node.offline && existsSync19(offlinePath)) {
+        const offlinePath = resolve20(appDir, node.sourceDir, "offline.vsk");
+        if (node.offline && existsSync20(offlinePath)) {
           compileFile2(offlinePath, node.offline, chunkCode);
         }
-        const networkPath = resolve19(appDir, node.sourceDir, "network.vsk");
-        if (node.network && existsSync19(networkPath)) {
+        const networkPath = resolve20(appDir, node.sourceDir, "network.vsk");
+        if (node.network && existsSync20(networkPath)) {
           compileFile2(networkPath, node.network, chunkCode);
         }
-        const loadingPath = resolve19(appDir, node.sourceDir, "loading.vsk");
-        if (node.loading && existsSync19(loadingPath)) {
+        const loadingPath = resolve20(appDir, node.sourceDir, "loading.vsk");
+        if (node.loading && existsSync20(loadingPath)) {
           compileFile2(loadingPath, node.loading, chunkCode);
         }
         if (chunkCode.length > 0) {
@@ -38397,7 +39695,7 @@ ${entry.code}
       if (seen.has(filePath))
         return;
       seen.add(filePath);
-      const src2 = readFileSync16(filePath, "utf-8");
+      const src2 = readFileSync18(filePath, "utf-8");
       resolveVskImports(filePath, (p, n) => compileFileMono2(p, n || ""));
       const compCode = compileClient(src2, null, { forceClient: true });
       if (compCode) {
@@ -38418,26 +39716,26 @@ ${entry.code}
       }
     }, walkMono2 = function(nodes) {
       for (const node of nodes) {
-        const pagePath = resolve19(appDir, node.sourceDir, "page.vsk");
-        if (node.page && existsSync19(pagePath))
+        const pagePath = resolve20(appDir, node.sourceDir, "page.vsk");
+        if (node.page && existsSync20(pagePath))
           compileFileMono2(pagePath, node.page);
-        const layoutPath = resolve19(appDir, node.sourceDir, "layout.vsk");
-        if (node.layout && existsSync19(layoutPath))
+        const layoutPath = resolve20(appDir, node.sourceDir, "layout.vsk");
+        if (node.layout && existsSync20(layoutPath))
           compileFileMono2(layoutPath, node.layout);
-        const errorPath = resolve19(appDir, node.sourceDir, "error.vsk");
-        if (node.error && existsSync19(errorPath))
+        const errorPath = resolve20(appDir, node.sourceDir, "error.vsk");
+        if (node.error && existsSync20(errorPath))
           compileFileMono2(errorPath, node.error);
-        const notFoundPath = resolve19(appDir, node.sourceDir, "not-found.vsk");
-        if (node.notFound && existsSync19(notFoundPath))
+        const notFoundPath = resolve20(appDir, node.sourceDir, "not-found.vsk");
+        if (node.notFound && existsSync20(notFoundPath))
           compileFileMono2(notFoundPath, node.notFound);
-        const offlinePath = resolve19(appDir, node.sourceDir, "offline.vsk");
-        if (node.offline && existsSync19(offlinePath))
+        const offlinePath = resolve20(appDir, node.sourceDir, "offline.vsk");
+        if (node.offline && existsSync20(offlinePath))
           compileFileMono2(offlinePath, node.offline);
-        const networkPath = resolve19(appDir, node.sourceDir, "network.vsk");
-        if (node.network && existsSync19(networkPath))
+        const networkPath = resolve20(appDir, node.sourceDir, "network.vsk");
+        if (node.network && existsSync20(networkPath))
           compileFileMono2(networkPath, node.network);
-        const loadingPath = resolve19(appDir, node.sourceDir, "loading.vsk");
-        if (node.loading && existsSync19(loadingPath))
+        const loadingPath = resolve20(appDir, node.sourceDir, "loading.vsk");
+        if (node.loading && existsSync20(loadingPath))
           compileFileMono2(loadingPath, node.loading);
         walkMono2(node.children || []);
       }
@@ -38487,9 +39785,9 @@ function buildRuntimeCode2(runtimeDir) {
   ];
   let code = "";
   for (const f of runtimeFiles) {
-    const p = join10(runtimeDir, f);
-    if (existsSync19(p)) {
-      let src2 = readFileSync16(p, "utf-8");
+    const p = join11(runtimeDir, f);
+    if (existsSync20(p)) {
+      let src2 = readFileSync18(p, "utf-8");
       src2 = stripTypes2(src2);
       src2 = src2.replace(/^import\s+[\s\S]*?from\s+['"](?:\.\/.*?|@vesk\/runtime\/src\/.*?)['"];?\n?/gm, "");
       src2 = src2.replace(/^import\s+['"](?:\.\/.*?|@vesk\/runtime\/src\/.*?)['"];?\n?/gm, "");
@@ -38501,7 +39799,7 @@ ${src2}
 `;
     }
   }
-  const indexSrc = readFileSync16(join10(runtimeDir, "index-client.js"), "utf-8");
+  const indexSrc = readFileSync18(join11(runtimeDir, "index-client.js"), "utf-8");
   const exportNames = stripTypes2(indexSrc).match(/export\s*\{\s*([^}]+)\s*\}\s*from/g)?.flatMap((m) => m.replace(/export\s*\{\s*|\s*\}\s*from/g, "").split(",").map((s) => s.trim())) || [];
   code += "// --- exports ---\n";
   for (const name of [...new Set(exportNames)]) {
@@ -38512,7 +39810,7 @@ ${src2}
   return code;
 }
 function runtimeExportNames2(runtimeDir) {
-  const indexSrc = readFileSync16(join10(runtimeDir, "index-client.js"), "utf-8");
+  const indexSrc = readFileSync18(join11(runtimeDir, "index-client.js"), "utf-8");
   const names = /* @__PURE__ */ new Set();
   for (const m of indexSrc.matchAll(/export\s*\{([^}]+)\}\s*from/g)) {
     for (const raw2 of m[1].split(",")) {
@@ -38532,7 +39830,7 @@ async function buildTreeShakenRuntime2(runtimeDir, usedNames) {
     console.error(`vesk: runtime names not exported \u2014 ${missing.join(", ")}; falling back to full runtime`);
     return buildRuntimeCode2(runtimeDir);
   }
-  const entry = join10(runtimeDir, `.runtime-tree-entry-${runtimeEntryId2++}.mjs`);
+  const entry = join11(runtimeDir, `.runtime-tree-entry-${runtimeEntryId2++}.mjs`);
   try {
     writeFileSync9(entry, `export { ${unique.join(", ")} } from './index-client.js';
 `);
@@ -38658,15 +39956,38 @@ if (typeof document !== 'undefined') __router.start();
 }
 
 // ../adapter/dist/paths.js
-import { resolve as resolve20, sep as sep4 } from "node:path";
+import { resolve as resolve21, sep as sep4 } from "node:path";
+import { existsSync as existsSync21, statSync as statSync14, readFileSync as readFileSync19 } from "node:fs";
 function resolveWithin2(baseDir, relPath) {
-  const base = resolve20(baseDir);
-  const target = resolve20(baseDir, relPath);
+  const base = resolve21(baseDir);
+  const target = resolve21(baseDir, relPath);
   const prefix = base + sep4;
   if (!target.startsWith(prefix))
     return null;
   return target;
 }
+function installMdReadHook2(publicDirs) {
+  const dirs = publicDirs.map((d) => resolve21(d));
+  globalThis.__vsk_md_read_file = (p) => {
+    for (const dir of dirs) {
+      try {
+        let rel = String(p);
+        while (rel.length > 0 && rel.charCodeAt(0) === 47)
+          rel = rel.slice(1);
+        const abs = resolveWithin2(dir, rel);
+        if (!abs)
+          continue;
+        const lower = abs.toLowerCase();
+        if (!lower.endsWith(".md") && !lower.endsWith(".markdown"))
+          continue;
+        if (existsSync21(abs) && statSync14(abs).isFile())
+          return readFileSync19(abs, "utf8");
+      } catch {
+      }
+    }
+    return null;
+  };
+}
 function isAllowedWsUpgrade(headers2) {
   const origin = typeof headers2["origin"] === "string" ? headers2["origin"] : "";
   if (!origin)
@@ -38728,13 +40049,13 @@ function urlAuthority3(url) {
 
 // src/build-packages.ts
 import { spawnSync } from "node:child_process";
-import { cpSync, existsSync as existsSync20, mkdirSync as mkdirSync7, readFileSync as readFileSync17, readdirSync as readdirSync9, statSync as statSync12, writeFileSync as writeFileSync10 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname13, join as join11, resolve as resolve21 } from "node:path";
+import { cpSync, existsSync as existsSync22, mkdirSync as mkdirSync7, readFileSync as readFileSync20, readdirSync as readdirSync9, statSync as statSync15, writeFileSync as writeFileSync10 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname14, join as join12, resolve as resolve22 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
-var require2 = createRequire2(import.meta.url);
-var __dirname8 = dirname13(fileURLToPath7(import.meta.url));
-var root2 = resolve21(__dirname8, "..", "..", "..");
+var require2 = createRequire3(import.meta.url);
+var __dirname8 = dirname14(fileURLToPath7(import.meta.url));
+var root2 = resolve22(__dirname8, "..", "..", "..");
 var PACKAGES = {
   // types first — it is a dependency-free leaf that compiler and adapter
   // import for their shared type definitions.
@@ -38750,8 +40071,8 @@ var PACKAGES = {
 function newestSourceMtime(srcDir) {
   let newest = 0;
   for (const name of readdirSync9(srcDir)) {
-    const p = join11(srcDir, name);
-    const st = statSync12(p);
+    const p = join12(srcDir, name);
+    const st = statSync15(p);
     if (st.isDirectory()) {
       newest = Math.max(newest, newestSourceMtime(p));
     } else if (st.isFile() && /\.ts$/.test(name) && !name.endsWith(".test.ts")) {
@@ -38761,11 +40082,11 @@ function newestSourceMtime(srcDir) {
   return newest;
 }
 function distStale(pkgDir, entry) {
-  const distIndex = join11(pkgDir, "dist", `${entry}.js`);
-  if (!existsSync20(distIndex)) return true;
-  const distPkg = join11(pkgDir, "dist", "package.json");
-  const distStamp = Math.max(statSync12(distIndex).mtimeMs, existsSync20(distPkg) ? statSync12(distPkg).mtimeMs : 0);
-  return newestSourceMtime(join11(pkgDir, "src")) > distStamp;
+  const distIndex = join12(pkgDir, "dist", `${entry}.js`);
+  if (!existsSync22(distIndex)) return true;
+  const distPkg = join12(pkgDir, "dist", "package.json");
+  const distStamp = Math.max(statSync15(distIndex).mtimeMs, existsSync22(distPkg) ? statSync15(distPkg).mtimeMs : 0);
+  return newestSourceMtime(join12(pkgDir, "src")) > distStamp;
 }
 function distPackageJson(pkgName, entry, serverEntry, version2) {
   const exports = {
@@ -38788,38 +40109,38 @@ function distPackageJson(pkgName, entry, serverEntry, version2) {
 }
 function buildPackages(force = false) {
   for (const [pkg, cfg] of Object.entries(PACKAGES)) {
-    const pkgDir = resolve21(root2, "packages", pkg);
-    if (!existsSync20(join11(pkgDir, "src"))) continue;
+    const pkgDir = resolve22(root2, "packages", pkg);
+    if (!existsSync22(join12(pkgDir, "src"))) continue;
     if (!force && !distStale(pkgDir, cfg.entry)) continue;
     console.log(`[build] ${cfg.name} -> tsc`);
     const tscBin = require2.resolve("typescript/bin/tsc");
-    const result2 = spawnSync(process.execPath, [tscBin, "-p", join11(pkgDir, "tsconfig.build.json")], {
+    const result2 = spawnSync(process.execPath, [tscBin, "-p", join12(pkgDir, "tsconfig.build.json")], {
       stdio: "inherit"
     });
     if (result2.status !== 0) {
       throw new Error(`tsc failed for ${cfg.name}`);
     }
-    const distDir = join11(pkgDir, "dist");
+    const distDir = join12(pkgDir, "dist");
     for (const c of cfg.copy || []) {
-      const to = join11(distDir, c.to);
-      mkdirSync7(dirname13(to), { recursive: true });
-      cpSync(join11(pkgDir, c.from), to, { recursive: true });
+      const to = join12(distDir, c.to);
+      mkdirSync7(dirname14(to), { recursive: true });
+      cpSync(join12(pkgDir, c.from), to, { recursive: true });
     }
-    const srcPkg = JSON.parse(readFileSync17(join11(pkgDir, "package.json"), "utf-8"));
-    writeFileSync10(join11(distDir, "package.json"), distPackageJson(cfg.name, cfg.entry, cfg.serverEntry, srcPkg.version || "1.0.0"));
+    const srcPkg = JSON.parse(readFileSync20(join12(pkgDir, "package.json"), "utf-8"));
+    writeFileSync10(join12(distDir, "package.json"), distPackageJson(cfg.name, cfg.entry, cfg.serverEntry, srcPkg.version || "1.0.0"));
     console.log(`[build] ${cfg.name} -> dist`);
   }
 }
 function ensurePackagesBuilt() {
   buildPackages(false);
 }
-if (process.argv[1] && resolve21(process.argv[1]) === fileURLToPath7(import.meta.url)) {
+if (process.argv[1] && resolve22(process.argv[1]) === fileURLToPath7(import.meta.url)) {
   buildPackages(process.argv.includes("--force"));
 }
 
 // src/action-handler.ts
-import { existsSync as existsSync21, readFileSync as readFileSync18, readdirSync as readdirSync10 } from "node:fs";
-import { resolve as resolve22 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync21, readdirSync as readdirSync10 } from "node:fs";
+import { resolve as resolve23 } from "node:path";
 
 // ../compiler/dist/server-cookies.js
 function parseCookies3(str) {
@@ -38896,8 +40217,8 @@ function pageSourcesFor(appDirPath, routeTree) {
   const out = [];
   function walk6(nodes) {
     for (const node of nodes) {
-      if (node.page) out.push(resolve22(appDirPath, node.sourceDir, "page.vsk"));
-      if (node.layout) out.push(resolve22(appDirPath, node.sourceDir, "layout.vsk"));
+      if (node.page) out.push(resolve23(appDirPath, node.sourceDir, "page.vsk"));
+      if (node.layout) out.push(resolve23(appDirPath, node.sourceDir, "layout.vsk"));
       walk6(node.children);
     }
   }
@@ -38905,7 +40226,7 @@ function pageSourcesFor(appDirPath, routeTree) {
   return out;
 }
 function walkVskFiles(dir, out, seen) {
-  if (!existsSync21(dir)) return;
+  if (!existsSync23(dir)) return;
   let entries;
   try {
     entries = readdirSync10(dir, { withFileTypes: true });
@@ -38913,7 +40234,7 @@ function walkVskFiles(dir, out, seen) {
     return;
   }
   for (const entry of entries) {
-    const full = resolve22(dir, entry.name);
+    const full = resolve23(dir, entry.name);
     if (seen.has(full)) continue;
     seen.add(full);
     if (entry.isDirectory()) {
@@ -38933,16 +40254,16 @@ function candidateSources(appDirPath, routeTree) {
     seen.add(src2);
     out.push(src2);
   }
-  const projectRoot = resolve22(appDirPath, "..");
-  for (const dir of [resolve22(projectRoot, "components"), appDirPath, projectRoot]) {
+  const projectRoot = resolve23(appDirPath, "..");
+  for (const dir of [resolve23(projectRoot, "components"), appDirPath, projectRoot]) {
     walkVskFiles(dir, out, seen);
   }
   return out;
 }
 function registerSource(sourcePath2) {
-  if (!existsSync21(sourcePath2)) return;
+  if (!existsSync23(sourcePath2)) return;
   try {
-    compileFile(readFileSync18(sourcePath2, "utf-8"), { sourcePath: sourcePath2 });
+    compileFile(readFileSync21(sourcePath2, "utf-8"), { sourcePath: sourcePath2 });
   } catch {
   }
 }
@@ -38951,8 +40272,8 @@ function ensureActionRegistered(actionId, pagePathname, appDirPath, routeTree) {
   const match = matchUrl(routeTree, pagePathname);
   if (match) {
     for (let i = match.nodes.length - 1; i >= 0; i--) {
-      registerSource(resolve22(appDirPath, match.nodes[i].sourceDir, "page.vsk"));
-      registerSource(resolve22(appDirPath, match.nodes[i].sourceDir, "layout.vsk"));
+      registerSource(resolve23(appDirPath, match.nodes[i].sourceDir, "page.vsk"));
+      registerSource(resolve23(appDirPath, match.nodes[i].sourceDir, "layout.vsk"));
     }
   }
   if (getAction2(actionId)) return;
@@ -38978,24 +40299,24 @@ async function renderPageHtml(pagePathname, params, ctx2) {
   let head = "";
   for (let i = chain.length - 1; i >= 0; i--) {
     const node = chain[i];
-    const pageFilePath = resolve22(ctx2.appDirPath, node.sourceDir, "page.vsk");
-    const layoutFilePath = resolve22(ctx2.appDirPath, node.sourceDir, "layout.vsk");
-    if (i === chain.length - 1 && node.page && existsSync21(pageFilePath)) {
-      const src3 = readFileSync18(pageFilePath, "utf-8");
+    const pageFilePath = resolve23(ctx2.appDirPath, node.sourceDir, "page.vsk");
+    const layoutFilePath = resolve23(ctx2.appDirPath, node.sourceDir, "layout.vsk");
+    if (i === chain.length - 1 && node.page && existsSync23(pageFilePath)) {
+      const src3 = readFileSync21(pageFilePath, "utf-8");
       const compName2 = resolveComponentName(src3) || node.page;
       const result2 = await renderPage(src3, compName2, { params }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: pageFilePath });
       body = result2.body;
       head = result2.head || "";
     }
-    if (node.layout && existsSync21(layoutFilePath)) {
-      const src3 = readFileSync18(layoutFilePath, "utf-8");
+    if (node.layout && existsSync23(layoutFilePath)) {
+      const src3 = readFileSync21(layoutFilePath, "utf-8");
       const compName2 = resolveComponentName(src3) || node.layout;
       const result2 = await renderPage(src3, compName2, { children: body }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: layoutFilePath });
       body = result2.body;
       head = (result2.head || "") + head;
     }
   }
-  const hasLayout = chain.some((n) => n.layout && existsSync21(resolve22(ctx2.appDirPath, n.sourceDir, "layout.vsk")));
+  const hasLayout = chain.some((n) => n.layout && existsSync23(resolve23(ctx2.appDirPath, n.sourceDir, "layout.vsk")));
   if (hasLayout) {
     const secMeta = securityMeta(ctx2.security);
     return `<!DOCTYPE html>
@@ -39017,9 +40338,9 @@ ${prettifyHtml(body)}
   }
   const leaf = chain.find((n) => n.page);
   if (!leaf) return null;
-  const src2 = readFileSync18(resolve22(ctx2.appDirPath, leaf.sourceDir, "page.vsk"), "utf-8");
+  const src2 = readFileSync21(resolve23(ctx2.appDirPath, leaf.sourceDir, "page.vsk"), "utf-8");
   const compName = resolveComponentName(src2) || leaf.page;
-  const html = await renderFullPage(src2, compName, { params }, /* @__PURE__ */ new Map(), { hydrate: true, clientScriptUrl: "/_vesk/client.js", cssUrls: ["/_vesk/static/_tailwind.css", "/_vesk/static/global.css"], security: ctx2.security, sourcePath: resolve22(ctx2.appDirPath, leaf.sourceDir, "page.vsk") });
+  const html = await renderFullPage(src2, compName, { params }, /* @__PURE__ */ new Map(), { hydrate: true, clientScriptUrl: "/_vesk/client.js", cssUrls: ["/_vesk/static/_tailwind.css", "/_vesk/static/global.css"], security: ctx2.security, sourcePath: resolve23(ctx2.appDirPath, leaf.sourceDir, "page.vsk") });
   return html.replace("</body>", '	<script type="module" src="/_vesk/hmr.js"></script>\n</body>');
 }
 async function handleActionRequest(req, res, ctx2) {
@@ -39163,14 +40484,14 @@ async function handleActionRequest(req, res, ctx2) {
 function resolveRuntimeDir(projectDir2) {
   const candidates = [
     // installed app layout
-    resolve23(projectDir2, "node_modules", "@vesk", "runtime"),
+    resolve24(projectDir2, "node_modules", "@vesk", "runtime"),
     // monorepo checkout (tests/probes run from the repo root)
-    resolve23(import.meta.dirname ?? ".", "..", "..", "runtime", "dist")
+    resolve24(import.meta.dirname ?? ".", "..", "..", "runtime", "dist")
   ];
   for (const dir of candidates) {
-    if (existsSync22(join12(dir, "ripple-runtime.js"))) return dir;
-    const distDir = join12(dir, "dist");
-    if (existsSync22(join12(distDir, "ripple-runtime.js"))) return distDir;
+    if (existsSync24(join13(dir, "ripple-runtime.js"))) return dir;
+    const distDir = join13(dir, "dist");
+    if (existsSync24(join13(distDir, "ripple-runtime.js"))) return distDir;
   }
   return null;
 }
@@ -39240,10 +40561,10 @@ function collectRoutePaths(nodes, out = []) {
   return out;
 }
 function countFilesNamed(dir, name) {
-  if (!existsSync22(dir)) return 0;
+  if (!existsSync24(dir)) return 0;
   let n = 0;
   for (const entry of readdirSync11(dir, { withFileTypes: true })) {
-    const p = join12(dir, entry.name);
+    const p = join13(dir, entry.name);
     if (entry.isDirectory()) n += countFilesNamed(p, name);
     else if (entry.name === name) n++;
   }
@@ -39254,8 +40575,9 @@ async function startDevServer(port2, projectDir2, config, host2) {
   if (!process.env.NODE_ENV) process.env.NODE_ENV = "development";
   const secCfg = config.security || {};
   const maxBodyBytes2 = (typeof secCfg.maxBodyBytes === "number" ? secCfg.maxBodyBytes : void 0) || DEFAULT_MAX_BODY_BYTES;
-  const appDirPath = join12(projectDir2, "app");
-  const publicDir = join12(projectDir2, "public");
+  const appDirPath = join13(projectDir2, "app");
+  const publicDir = join13(projectDir2, "public");
+  installMdReadHook2([publicDir]);
   try {
     ensurePackagesBuilt();
   } catch (e) {
@@ -39272,14 +40594,14 @@ async function startDevServer(port2, projectDir2, config, host2) {
   let devTailwindCssContent = "";
   let lastServedCssGlobal = "";
   let lastServedCssTailwind = "";
-  const srcDir = join12(projectDir2, "src");
-  const cssPath = join12(srcDir, "global.css");
-  const altCssPath = join12(srcDir, "app.css");
+  const srcDir = join13(projectDir2, "src");
+  const cssPath = join13(srcDir, "global.css");
+  const altCssPath = join13(srcDir, "app.css");
   let rawCss = "";
-  if (existsSync22(cssPath)) {
-    rawCss = readFileSync19(cssPath, "utf-8");
-  } else if (existsSync22(altCssPath)) {
-    rawCss = readFileSync19(altCssPath, "utf-8");
+  if (existsSync24(cssPath)) {
+    rawCss = readFileSync22(cssPath, "utf-8");
+  } else if (existsSync24(altCssPath)) {
+    rawCss = readFileSync22(altCssPath, "utf-8");
   }
   if (rawCss) {
     for (const plugin of devPlugins) {
@@ -39405,7 +40727,7 @@ async function startDevServer(port2, projectDir2, config, host2) {
     let debounceTimer = null;
     let cssDebounceTimer = null;
     const watchDirs = [appDirPath];
-    if (existsSync22(srcDir)) watchDirs.push(srcDir);
+    if (existsSync24(srcDir)) watchDirs.push(srcDir);
     for (const watchDir of watchDirs) {
       watch(watchDir, { recursive: true }, (eventType, filename) => {
         if (!filename) return;
@@ -39413,8 +40735,8 @@ async function startDevServer(port2, projectDir2, config, host2) {
         const isCss = filename.endsWith(".css");
         const isApiRoute = filename.endsWith(".ts") || filename.endsWith(".js") || filename.endsWith(".tsx");
         if (!isVsk && !isCss && !isApiRoute) return;
-        const fullPath = filename.startsWith("/") ? filename : join12(watchDir, filename);
-        const fileExists = existsSync22(fullPath);
+        const fullPath = filename.startsWith("/") ? filename : join13(watchDir, filename);
+        const fileExists = existsSync24(fullPath);
         if (isVsk) {
           if (debounceTimer) clearTimeout(debounceTimer);
           debounceTimer = setTimeout(async () => {
@@ -39463,7 +40785,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
                     if (compCode.trim()) fnSources = { _raw: compCode };
                   } else if (fileExists && !bundleError) {
                     try {
-                      const src2 = readFileSync19(fullPath, "utf-8");
+                      const src2 = readFileSync22(fullPath, "utf-8");
                       let compCode = compileClient2(src2, null, { forceClient: true, sourcePath: fullPath, mdRoots: [projectDir2] });
                       compCode = compCode.replace(/^import\s*[\s\S]*?from\s*['"][^'"]+['"];?\s*\n?/gm, "");
                       compCode = compCode.replace(/^const __components = \{\};\s*\n?/m, "");
@@ -39519,7 +40841,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
                     let code = "";
                     if (line > 0 && fileExists) {
                       try {
-                        const src2 = readFileSync19(fullPath, "utf-8");
+                        const src2 = readFileSync22(fullPath, "utf-8");
                         const lines = src2.split("\n");
                         const start = Math.max(0, line - 3);
                         const end = Math.min(lines.length, line + 2);
@@ -39570,7 +40892,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
           cssDebounceTimer = setTimeout(async () => {
             try {
               if (fileExists) {
-                rawCss = readFileSync19(fullPath, "utf-8");
+                rawCss = readFileSync22(fullPath, "utf-8");
               }
               const cssChanged = await rebuildTailwindCss();
               if (cssChanged && typeof globalThis.__vesk_broadcastHmr === "function") {
@@ -39602,9 +40924,9 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
     ".html": "text/html",
     ".json": "application/json"
   };
-  const hmrJsPath = join12(runtimeDir, "hmr-client.js");
-  const hmrTsPath = join12(runtimeDir, "hmr-client.ts");
-  const hmrClientPath = existsSync22(hmrJsPath) ? hmrJsPath : existsSync22(hmrTsPath) ? hmrTsPath : null;
+  const hmrJsPath = join13(runtimeDir, "hmr-client.js");
+  const hmrTsPath = join13(runtimeDir, "hmr-client.ts");
+  const hmrClientPath = existsSync24(hmrJsPath) ? hmrJsPath : existsSync24(hmrTsPath) ? hmrTsPath : null;
   function extractCompName2(src2) {
     return resolveComponentName(src2);
   }
@@ -39705,7 +41027,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
     }
     if (url.pathname === "/_vesk/hmr" || url.pathname === "/_vesk/hmr.js") {
       if (hmrClientPath) {
-        let hmrContent = readFileSync19(hmrClientPath, "utf-8");
+        let hmrContent = readFileSync22(hmrClientPath, "utf-8");
         if (hmrClientPath.endsWith(".ts")) {
           hmrContent = stripCodeTypes2(hmrContent);
         }
@@ -39719,16 +41041,16 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
     }
     if (url.pathname !== "/") {
       const staticPath = url.pathname.length > 1 ? resolveWithin2(publicDir, url.pathname.slice(1)) : null;
-      if (staticPath && existsSync22(staticPath) && statSync13(staticPath).isFile()) {
-        const ext = extname5(staticPath);
+      if (staticPath && existsSync24(staticPath) && statSync16(staticPath).isFile()) {
+        const ext = extname6(staticPath);
         res.writeHead(200, { "Content-Type": MIME3[ext] || "application/octet-stream" });
-        res.end(readFileSync19(staticPath));
+        res.end(readFileSync22(staticPath));
         return;
       }
     }
     const mwChain = collectMiddlewareChain(routeTree, url.pathname, appDirPath);
-    const apiDirPath = join12(appDirPath, "api");
-    if (url.pathname.startsWith("/api") && existsSync22(apiDirPath)) {
+    const apiDirPath = join13(appDirPath, "api");
+    if (url.pathname.startsWith("/api") && existsSync24(apiDirPath)) {
       const apiRoutes = await scanApiRoutes(apiDirPath);
       const apiMatch = matchApiUrl(apiRoutes, req.url || url.pathname);
       if (apiMatch) {
@@ -39803,10 +41125,10 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
       const rootNode = routeTree.find((n) => n.fullPath === "/");
       let notFoundHtml = null;
       if (rootNode && rootNode.notFound) {
-        const nfPath = resolve23(appDirPath, rootNode.sourceDir, "not-found.vsk");
-        if (existsSync22(nfPath)) {
+        const nfPath = resolve24(appDirPath, rootNode.sourceDir, "not-found.vsk");
+        if (existsSync24(nfPath)) {
           try {
-            const nfSrc = readFileSync19(nfPath, "utf-8");
+            const nfSrc = readFileSync22(nfPath, "utf-8");
             const nfCompName = extractCompName2(nfSrc) || rootNode.notFound;
             notFoundHtml = await renderFullPage(nfSrc, nfCompName, { params: {}, url: url.pathname }, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: ["/_vesk/static/_tailwind.css", "/_vesk/static/global.css"], security, externalDataScript: storeDataScript, sourcePath: nfPath });
           } catch {
@@ -39843,18 +41165,18 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
         let props;
         for (let i = chain.length - 1; i >= 0; i--) {
           const node = chain[i];
-          const pageFilePath = resolve23(appDirPath, node.sourceDir, "page.vsk");
-          const layoutFilePath = resolve23(appDirPath, node.sourceDir, "layout.vsk");
-          if (i === chain.length - 1 && node.page && existsSync22(pageFilePath)) {
-            const src2 = readFileSync19(pageFilePath, "utf-8");
+          const pageFilePath = resolve24(appDirPath, node.sourceDir, "page.vsk");
+          const layoutFilePath = resolve24(appDirPath, node.sourceDir, "layout.vsk");
+          if (i === chain.length - 1 && node.page && existsSync24(pageFilePath)) {
+            const src2 = readFileSync22(pageFilePath, "utf-8");
             const compName = extractCompName2(src2) || node.page;
             const result2 = await renderPage(src2, compName, { params: matched.params }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: pageFilePath });
             body = result2.body;
             head = result2.head || "";
             props = result2.props;
           }
-          if (node.layout && existsSync22(layoutFilePath)) {
-            const src2 = readFileSync19(layoutFilePath, "utf-8");
+          if (node.layout && existsSync24(layoutFilePath)) {
+            const src2 = readFileSync22(layoutFilePath, "utf-8");
             const compName = extractCompName2(src2) || node.layout;
             const result2 = await renderPage(src2, compName, { children: body }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: layoutFilePath });
             body = result2.body;
@@ -39864,7 +41186,7 @@ Object.defineProperty(__components, ${JSON.stringify(cname)}, { get: () => __com
         if (forData) {
           return { html: "", props: props || { params: matched.params }, head };
         }
-        const hasLayout = chain.some((n) => n.layout && existsSync22(resolve23(appDirPath, n.sourceDir, "layout.vsk")));
+        const hasLayout = chain.some((n) => n.layout && existsSync24(resolve24(appDirPath, n.sourceDir, "layout.vsk")));
         let html;
         if (hasLayout) {
           const ssrData = ssrSink3.snapshot();
@@ -39896,9 +41218,9 @@ ${prettifyHtml(body)}
         } else {
           const leaf = chain.find((n) => n.page);
           if (leaf) {
-            const src2 = readFileSync19(resolve23(appDirPath, leaf.sourceDir, "page.vsk"), "utf-8");
+            const src2 = readFileSync22(resolve24(appDirPath, leaf.sourceDir, "page.vsk"), "utf-8");
             const compName = extractCompName2(src2) || leaf.page;
-            html = await renderFullPage(src2, compName, { params: matched.params }, /* @__PURE__ */ new Map(), { hydrate: true, clientScriptUrl: "/_vesk/client.js", cssUrls: ["/_vesk/static/_tailwind.css", "/_vesk/static/global.css"], security, externalDataScript: storeDataScript, sourcePath: resolve23(appDirPath, leaf.sourceDir, "page.vsk") });
+            html = await renderFullPage(src2, compName, { params: matched.params }, /* @__PURE__ */ new Map(), { hydrate: true, clientScriptUrl: "/_vesk/client.js", cssUrls: ["/_vesk/static/_tailwind.css", "/_vesk/static/global.css"], security, externalDataScript: storeDataScript, sourcePath: resolve24(appDirPath, leaf.sourceDir, "page.vsk") });
             html = html.replace("</body>", '	<script type="module" src="/_vesk/hmr.js"></script>\n</body>');
           } else {
             throw new Error("No page or layout matched");
@@ -39910,13 +41232,13 @@ ${prettifyHtml(body)}
     function renderSSRStream() {
       async function* raw2() {
         const chain = cleanChain;
-        const hasLayout = chain.some((n) => n.layout && existsSync22(resolve23(appDirPath, n.sourceDir, "layout.vsk")));
+        const hasLayout = chain.some((n) => n.layout && existsSync24(resolve24(appDirPath, n.sourceDir, "layout.vsk")));
         if (!hasLayout) {
           const leaf = chain.find((n) => n.page);
           if (leaf) {
-            const src2 = readFileSync19(resolve23(appDirPath, leaf.sourceDir, "page.vsk"), "utf-8");
+            const src2 = readFileSync22(resolve24(appDirPath, leaf.sourceDir, "page.vsk"), "utf-8");
             const compName = extractCompName2(src2) || leaf.page;
-            yield* renderPageStream(src2, compName, { params: matched.params }, /* @__PURE__ */ new Map(), { hydrate: true, clientScriptUrl: "/_vesk/client.js", cssUrls: ["/_vesk/static/_tailwind.css", "/_vesk/static/global.css"], security, externalDataScript: storeDataScript, sourcePath: resolve23(appDirPath, leaf.sourceDir, "page.vsk") });
+            yield* renderPageStream(src2, compName, { params: matched.params }, /* @__PURE__ */ new Map(), { hydrate: true, clientScriptUrl: "/_vesk/client.js", cssUrls: ["/_vesk/static/_tailwind.css", "/_vesk/static/global.css"], security, externalDataScript: storeDataScript, sourcePath: resolve24(appDirPath, leaf.sourceDir, "page.vsk") });
           } else {
             throw new Error("No page or layout matched");
           }
@@ -39927,18 +41249,18 @@ ${prettifyHtml(body)}
         let props;
         for (let i = chain.length - 1; i >= 0; i--) {
           const node = chain[i];
-          const pageFilePath = resolve23(appDirPath, node.sourceDir, "page.vsk");
-          const layoutFilePath = resolve23(appDirPath, node.sourceDir, "layout.vsk");
-          if (i === chain.length - 1 && node.page && existsSync22(pageFilePath)) {
-            const src2 = readFileSync19(pageFilePath, "utf-8");
+          const pageFilePath = resolve24(appDirPath, node.sourceDir, "page.vsk");
+          const layoutFilePath = resolve24(appDirPath, node.sourceDir, "layout.vsk");
+          if (i === chain.length - 1 && node.page && existsSync24(pageFilePath)) {
+            const src2 = readFileSync22(pageFilePath, "utf-8");
             const compName = extractCompName2(src2) || node.page;
             const result2 = await renderPage(src2, compName, { params: matched.params }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: pageFilePath });
             body = result2.body;
             head = result2.head || "";
             props = result2.props;
           }
-          if (node.layout && existsSync22(layoutFilePath)) {
-            const src2 = readFileSync19(layoutFilePath, "utf-8");
+          if (node.layout && existsSync24(layoutFilePath)) {
+            const src2 = readFileSync22(layoutFilePath, "utf-8");
             const compName = extractCompName2(src2) || node.layout;
             const result2 = await renderPage(src2, compName, { children: body }, /* @__PURE__ */ new Map(), { hydrate: true, sourcePath: layoutFilePath });
             body = result2.body;
@@ -40065,10 +41387,10 @@ ${prettifyHtml(body)}
           for (let i = match.nodes.length - 1; i >= 0; i--) {
             const node = match.nodes[i];
             if (node.notFound) {
-              const nfPath = resolve23(appDirPath, node.sourceDir, "not-found.vsk");
-              if (existsSync22(nfPath)) {
+              const nfPath = resolve24(appDirPath, node.sourceDir, "not-found.vsk");
+              if (existsSync24(nfPath)) {
                 try {
-                  const nfSrc = readFileSync19(nfPath, "utf-8");
+                  const nfSrc = readFileSync22(nfPath, "utf-8");
                   const nfCompName = extractCompName2(nfSrc) || node.notFound;
                   const html = await renderFullPage(nfSrc, nfCompName, { params: match.params, url: url.pathname }, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: ["/_vesk/static/_tailwind.css", "/_vesk/static/global.css"], security, externalDataScript: storeDataScript, sourcePath: nfPath });
                   notFoundHtml = html.replace(
@@ -40093,10 +41415,10 @@ ${prettifyHtml(body)}
           for (let i = match.nodes.length - 1; i >= 0; i--) {
             const node = match.nodes[i];
             if (node.error) {
-              const errPath = resolve23(appDirPath, node.sourceDir, "error.vsk");
-              if (existsSync22(errPath)) {
+              const errPath = resolve24(appDirPath, node.sourceDir, "error.vsk");
+              if (existsSync24(errPath)) {
                 try {
-                  const errSrc = readFileSync19(errPath, "utf-8");
+                  const errSrc = readFileSync22(errPath, "utf-8");
                   const errCompName = extractCompName2(errSrc) || node.error;
                   const errProps = { error: err.message, stack: err.stack, statusCode: errorStatusCode(err), url: url.pathname };
                   const html = await renderFullPage(errSrc, errCompName, errProps, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: ["/_vesk/static/_tailwind.css", "/_vesk/static/global.css"], security, externalDataScript: storeDataScript, sourcePath: errPath });
@@ -40130,7 +41452,7 @@ ${err.stack}</pre></body></html>`);
     LOG.ok(`dev server at http://localhost:${port2} (listening on ${bindHost})`);
     const routes = collectRoutePaths(routeTree);
     const pageCount = countPages(routeTree);
-    const apiCount = countFilesNamed(join12(appDirPath, "api"), "route.ts");
+    const apiCount = countFilesNamed(join13(appDirPath, "api"), "route.ts");
     LOG.info(`${projectDir2}`);
     LOG.info(`${pageCount} page${pageCount === 1 ? "" : "s"}: ${routes.join(", ") || "(none)"}`);
     if (apiCount > 0) LOG.info(`${apiCount} api route${apiCount === 1 ? "" : "s"} (app/api)`);
@@ -40359,7 +41681,7 @@ init_action();
 
 // src/index.ts
 var __filename2 = fileURLToPath8(import.meta.url);
-var __dirname9 = resolve25(__filename2, "..");
+var __dirname9 = resolve26(__filename2, "..");
 var args = process.argv.slice(2);
 var cmd = args[0];
 function usage(code = 0) {
@@ -40402,12 +41724,12 @@ if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
 }
 function loadEnvFiles(projectDir2) {
   const files = [
-    join14(projectDir2, ".env"),
-    join14(projectDir2, ".env.local")
+    join15(projectDir2, ".env"),
+    join15(projectDir2, ".env.local")
   ];
   for (const filePath of files) {
-    if (!existsSync23(filePath)) continue;
-    const content = readFileSync21(filePath, "utf-8");
+    if (!existsSync25(filePath)) continue;
+    const content = readFileSync24(filePath, "utf-8");
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
@@ -40426,22 +41748,22 @@ function loadEnvFiles(projectDir2) {
 }
 async function loadConfig(projectDir2) {
   loadEnvFiles(projectDir2);
-  const jsPath = join14(projectDir2, "vesk.config.js");
-  const tsPath = join14(projectDir2, "vesk.config.ts");
+  const jsPath = join15(projectDir2, "vesk.config.js");
+  const tsPath = join15(projectDir2, "vesk.config.ts");
   let configPath2 = null;
-  if (existsSync23(jsPath)) configPath2 = jsPath;
-  else if (existsSync23(tsPath)) configPath2 = tsPath;
+  if (existsSync25(jsPath)) configPath2 = jsPath;
+  else if (existsSync25(tsPath)) configPath2 = tsPath;
   if (!configPath2) return {};
   let raw2;
   if (configPath2.endsWith(".ts")) {
     const { transpile: transpile2 } = await import("typescript");
-    const src2 = readFileSync21(configPath2, "utf-8");
+    const src2 = readFileSync24(configPath2, "utf-8");
     let js = transpile2(src2, { module: 99, target: 99 });
     js = js.replace(/import\s+\{[^}]*\}\s*from\s+['"]@vesk\/compiler['"]\s*;?\s*/g, "");
     js = `const { defineConfig, definePlugin, preset } = globalThis.__vesk_inject;
 ` + js;
-    const tmpFile = join14(projectDir2, ".vesk", "config.tmp.js");
-    mkdirSync9(dirname15(tmpFile), { recursive: true });
+    const tmpFile = join15(projectDir2, ".vesk", "config.tmp.js");
+    mkdirSync9(dirname16(tmpFile), { recursive: true });
     writeFileSync11(tmpFile, js, "utf-8");
     globalThis.__vesk_inject = { defineConfig, definePlugin, preset };
     raw2 = (await import(tmpFile)).default;
@@ -40462,9 +41784,9 @@ async function loadConfig(projectDir2) {
 }
 if (cmd === "build") {
   const projectDir2 = process.cwd();
-  const appDirPath = join14(projectDir2, "app");
-  const publicDir = join14(projectDir2, "public");
-  if (!existsSync23(appDirPath)) {
+  const appDirPath = join15(projectDir2, "app");
+  const publicDir = join15(projectDir2, "public");
+  if (!existsSync25(appDirPath)) {
     console.error(`vesk build: no app/ directory found in ${projectDir2}`);
     process.exit(1);
   }
@@ -40502,8 +41824,8 @@ if (cmd === "build") {
 }
 if (cmd === "seo") {
   const projectDir2 = process.cwd();
-  const appDirPath = join14(projectDir2, "app");
-  if (!existsSync23(appDirPath)) {
+  const appDirPath = join15(projectDir2, "app");
+  if (!existsSync25(appDirPath)) {
     console.error(`vesk seo: no app/ directory found in ${projectDir2}`);
     process.exit(1);
   }
@@ -40517,8 +41839,8 @@ if (cmd === "seo") {
 }
 if (cmd === "typecheck") {
   const projectDir2 = process.cwd();
-  const appDirPath = join14(projectDir2, "app");
-  if (!existsSync23(appDirPath)) {
+  const appDirPath = join15(projectDir2, "app");
+  if (!existsSync25(appDirPath)) {
     console.error(`vesk typecheck: no app/ directory found in ${projectDir2}`);
     process.exit(1);
   }
@@ -40542,7 +41864,7 @@ if (cmd === "typecheck") {
 }
 if (cmd === "start") {
   const projectDir2 = process.cwd();
-  const outDir2 = join14(projectDir2, ".vesk");
+  const outDir2 = join15(projectDir2, ".vesk");
   const port2 = parsePortArg(args);
   const host2 = parseHostArg(args);
   startProdServer(outDir2, { port: port2, host: host2 });
@@ -40551,9 +41873,9 @@ if (cmd === "start") {
 }
 if (cmd === "init") {
   const projectDir2 = process.cwd();
-  const srcDir = join14(projectDir2, "src");
-  const target = join14(srcDir, "global.css");
-  if (existsSync23(target)) {
+  const srcDir = join15(projectDir2, "src");
+  const target = join15(srcDir, "global.css");
+  if (existsSync25(target)) {
     console.error(`vesk init: ${target} already exists \u2014 skipping`);
     process.exit(0);
   }
@@ -40571,10 +41893,10 @@ if (cmd === "init") {
 }
 if (cmd === "dev") {
   const projectDir2 = process.cwd();
-  const appDirPath = join14(projectDir2, "app");
+  const appDirPath = join15(projectDir2, "app");
   const port2 = parsePortArg(args);
   const host2 = parseHostArg(args);
-  if (!existsSync23(appDirPath)) {
+  if (!existsSync25(appDirPath)) {
     console.error(`vesk: no app/ directory found in ${projectDir2}`);
     console.error('Run "npx create-vesk@latest <project-name>" first');
     process.exit(1);