@marko/run 0.10.0 → 0.11.0-rc.1

package/dist/vite/index.js

@@ -17,6 +17,9 @@ import { resolveToEsbuildTarget } from "esbuild-plugin-browserslist";
 import fs3 from "fs";
 import { glob } from "glob";
 import path6 from "path";
+import {
+  RolldownMagicString
+} from "rolldown";
 import { fileURLToPath } from "url";
 import {
   buildErrorMessage,
@@ -65,10 +68,10 @@ var httpVerbs = [
   "options"
 ];
 var RoutableFileTypes = {
-  Page: "page",
-  Layout: "layout",
-  Handler: "handler",
   Middleware: "middleware",
+  Handler: "handler",
+  Layout: "layout",
+  Page: "page",
   Meta: "meta",
   NotFound: "404",
   Error: "500"
@@ -257,19 +260,21 @@ function normalizedRelativePath(from, to) {
   const relativePath = normalizePath(path2.relative(from, to));
   return relativePath.startsWith(".") ? relativePath : "./" + relativePath;
 }
-function renderRouteTemplate(route, markoApi) {
+function renderRouteTemplate(route, markoApi, dev = false) {
   if (!route.page) {
     throw new Error(`Route ${route.key} has no page to render`);
   }
-  if (!route.templateFilePath) {
-    throw new Error(`Route ${route.key} has no template file path`);
-  }
   const writer = createStringWriter();
   if (markoApi) {
     writer.writeLines(`<!-- use ${markoApi} -->
 `);
   }
-  writer.branch("imports");
+  const importWriter = writer.branch("imports");
+  if (dev) {
+    importWriter.writeLines(
+      `client import "virtual:marko-run/runtime/client";`
+    );
+  }
   writer.writeLines("");
   writeEntryTemplateTag(
     writer,
@@ -317,7 +322,10 @@ function renderRouteEntry(route, rootDir) {
     runtimeImports.push("normalizeMeta");
   }
   if (handler || middleware.length) {
-    runtimeImports.push("call");
+    runtimeImports.push("call", "mergeOptions");
+  }
+  if (page) {
+    runtimeImports.push("render");
   }
   if (!page || verbs.some((verb) => verb !== "get" && verb !== "head")) {
     runtimeImports.push("noContent");
@@ -356,7 +364,7 @@ function renderRouteEntry(route, rootDir) {
   }
   if (page) {
     imports.writeLines(
-      `import page from "${normalizedRelativePath(rootDir, route.templateFilePath || page.filePath)}";`
+      `import page from "${normalizedRelativePath(rootDir, route.templateFilePath)}";`
     );
   }
   if (meta) {
@@ -374,11 +382,34 @@ function renderRouteEntry(route, rootDir) {
       `export const { ${metaVerbsExports} } = normalizeMeta(${metaName});`
     );
   }
+  const optionsWriter = writer.branch("options").writeLines("");
   for (const verb of verbs) {
+    writeRouteOptions(optionsWriter, route, verb);
     writeRouteEntryHandler(writer, route, verb);
   }
+  optionsWriter.join();
   return writer.end();
 }
+function writeRouteOptions(writer, route, verb) {
+  var _a, _b;
+  const hasHandler = (_b = (_a = route.handler) == null ? void 0 : _a.verbs) == null ? void 0 : _b.includes(verb);
+  writer.write(`export const ${verb}${route.index}_options = `);
+  if (route.middleware.length || hasHandler) {
+    writer.write(`mergeOptions(`);
+    let sep = "";
+    for (const { id } of route.middleware) {
+      writer.write(`${sep}mware${id}`);
+      sep = ", ";
+    }
+    if (hasHandler) {
+      writer.write(`${sep}${verb}Handler`);
+    }
+    writer.write(");");
+  } else {
+    writer.write("{};");
+  }
+  writer.write("\n");
+}
 function writeRouteEntryHandler(writer, route, verb) {
   var _a, _b, _c, _d;
   const { key, index, page, handler, middleware } = route;
@@ -398,13 +429,13 @@ function writeRouteEntryHandler(writer, route, verb) {
     if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes(verb)) {
       const name = `${verb}Handler`;
       continuations.writeLines(
-        `const ${currentName} = () => context.render(page, {});`
+        `const ${currentName} = (data) => render(context, page, {}, data);`
       );
       if (len) {
         nextName = currentName;
         currentName = `__${name}`;
         continuations.writeLines(
-          `const ${currentName} = () => call(${name}, ${nextName}, context);`
+          `const ${currentName} = (data) => call(${name}, ${nextName}, context, data);`
         );
       } else {
         if (verb === "head") {
@@ -421,10 +452,10 @@ function writeRouteEntryHandler(writer, route, verb) {
       hasBody = true;
     } else if (len) {
       continuations.writeLines(
-        `const ${currentName} = () => context.render(page, {});`
+        `const ${currentName} = (data) => render(context, page, {}, data);`
       );
     } else {
-      writer.writeLines(`return context.render(page, {});`);
+      writer.writeLines(`return render(context, page, {});`);
       hasBody = true;
     }
   } else if ((_b = handler == null ? void 0 : handler.verbs) == null ? void 0 : _b.includes(verb)) {
@@ -433,7 +464,7 @@ function writeRouteEntryHandler(writer, route, verb) {
     nextName = "noContent";
     if (len) {
       continuations.writeLines(
-        `const ${currentName} = () => call(${name}, ${nextName}, context);`
+        `const ${currentName} = (data) => call(${name}, ${nextName}, context, data);`
       );
     } else {
       if (verb === "head") {
@@ -460,7 +491,7 @@ function writeRouteEntryHandler(writer, route, verb) {
       currentName = i ? `__${name}` : "";
       if (currentName) {
         continuations.writeLines(
-          `const ${currentName} = () => call(${name}, ${nextName}, context);`
+          `const ${currentName} = (data) => call(${name}, ${nextName}, context, data);`
         );
       } else if (verb === "head") {
         continuations.writeLines(
@@ -493,6 +524,7 @@ function renderRouter(routes, rootDir, runtimeInclude, options = {
     for (const verb of verbs) {
       const verbName = `${verb}${route.index}`;
       routeImports.push(verbName);
+      routeImports.push(`${verbName}_options`);
       if (route.meta) {
         routeImports.push(`${verbName}_meta`);
       }
@@ -503,7 +535,7 @@ function renderRouter(routes, rootDir, runtimeInclude, options = {
   }
   for (const route of Object.values(routes.special)) {
     imports.writeLines(
-      `import page${route.key} from "${normalizedRelativePath(rootDir, route.templateFilePath || route.page.filePath)}";`
+      `import page${route.key} from "${normalizedRelativePath(rootDir, route.templateFilePath)}";`
     );
   }
   writer.writeLines(
@@ -788,10 +820,10 @@ function renderParams(params, pathIndex) {
   return result ? result + " }" : "{}";
 }
 function renderMatch(verb, route, path7, pathIndex) {
-  const handler = `${verb}${route.index}`;
+  const name = `${verb}${route.index}`;
   const params = path7.params ? renderParams(path7.params, pathIndex) : "{}";
-  const meta = route.meta ? `${verb}${route.index}_meta` : "{}";
-  return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${path7.path}' }`;
+  const meta = route.meta ? `${name}_meta` : "{}";
+  return `{ handler: ${name}, path: '${path7.path}', params: ${params}, options: ${name}_options, meta: ${meta} }`;
 }
 function renderMiddleware(middleware, rootDir) {
   const writer = createStringWriter();
@@ -822,8 +854,14 @@ function stripTsExtension(path7) {
   }
   return path7;
 }
+function* routeFileIter(route) {
+  yield* route.middleware;
+  if (route.handler) yield route.handler;
+  yield* route.layouts;
+  if (route.page) yield route.page;
+  if (route.meta) yield route.meta;
+}
 async function renderRouteTypeInfo(routes, outDir, adapter) {
-  var _a, _b, _c, _d;
   const writer = createStringWriter();
   writer.writeLines(
     `/*
@@ -832,10 +870,11 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
 */
 `,
     `import { NotHandled, NotMatched, GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform } from "@marko/run/namespace";`,
-    `import type * as Run from "@marko/run";`
+    `import type * as $ from "@marko/run";`,
+    ""
   );
   const headWriter = writer.branch("head");
-  writer.writeLines("\n").writeBlockStart(`declare module "@marko/run" {`);
+  writer.writeLines("").writeBlockStart(`declare module "@marko/run" {`);
   if (adapter && adapter.typeInfo) {
     const platformType = await adapter.typeInfo(
       (data) => headWriter.write(data)
@@ -845,139 +884,120 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
 `);
     }
   }
-  headWriter.join();
-  writer.writeBlockStart(`interface AppData extends Run.DefineApp<{`).writeBlockStart("routes: {");
-  const routesWriter = writer.branch("routes");
-  writer.writeBlockEnd("}").writeBlockEnd(`}> {}`).writeBlockEnd(`}`);
-  const routeTypes = /* @__PURE__ */ new Map();
-  for (const route of routes.list) {
-    let routeType = "";
-    let routeDefinition = "";
-    if (route.page || route.handler) {
-      const verbs = [];
-      if (route.page || ((_b = (_a = route.handler) == null ? void 0 : _a.verbs) == null ? void 0 : _b.includes("get"))) {
-        verbs.push(`"get"`);
-      }
-      if ((_d = (_c = route.handler) == null ? void 0 : _c.verbs) == null ? void 0 : _d.includes("post")) {
-        verbs.push(`"post"`);
-      }
-      routeDefinition = `{ verb: ${verbs.join(" | ")};`;
-      if (route.meta) {
-        const metaPath = stripTsExtension(
-          normalizedRelativePath(outDir, route.meta.filePath)
-        );
-        let metaType = `typeof import("${metaPath}")`;
-        if (/\.(ts|js|mjs)$/.test(route.meta.name)) {
-          metaType += `["default"]`;
-        }
-        routeDefinition += ` meta: ${metaType};`;
-      }
-      routeDefinition += " }";
-    }
-    const pathType = `"${route.path.path}"`;
-    routeType += routeType ? " | " + pathType : pathType;
-    routesWriter.writeLines(`${pathType}: ${routeDefinition};`);
-    for (const file of [route.handler, route.page]) {
-      if (file) {
-        const existing = routeTypes.get(file);
-        if (!existing) {
-          routeTypes.set(file, [routeType]);
-        } else {
-          existing.push(routeType);
-        }
+  const fileInfoByType = /* @__PURE__ */ new Map();
+  let fileIndex = 1;
+  function addFile(file) {
+    let group = fileInfoByType.get(file.type);
+    if (!group) {
+      fileInfoByType.set(file.type, group = /* @__PURE__ */ new Map());
+    }
+    let info = group.get(file);
+    if (!info) {
+      info = {
+        id: "",
+        typeName: null,
+        modulePath: stripTsExtension(
+          normalizedRelativePath(outDir, file.filePath)
+        ),
+        routes: /* @__PURE__ */ new Set()
+      };
+      switch (file.type) {
+        case RoutableFileTypes.Middleware:
+          info.id = `M${group.size + 1}`;
+          info.typeName = "Middleware";
+          break;
+        case RoutableFileTypes.Handler:
+          info.id = `H${group.size + 1}`;
+          info.typeName = "Handler";
+          break;
+        case RoutableFileTypes.Meta:
+          info.id = `D${group.size + 1}`;
+          info.typeName = "Meta";
+          break;
+        case RoutableFileTypes.Layout:
+          info.id = `L${group.size + 1}`;
+          info.typeName = "Template";
+          break;
+        case RoutableFileTypes.Page:
+          info.id = `P${group.size + 1}`;
+          info.typeName = "Template";
+          break;
+        default:
+          info.id = `F${fileIndex++}`;
+          break;
       }
+      group.set(file, info);
     }
-    for (const files of [route.middleware, route.layouts]) {
-      if (files) {
-        for (const file of files) {
-          const existing = routeTypes.get(file);
-          if (!existing) {
-            routeTypes.set(file, [routeType]);
-          } else {
-            existing.push(routeType);
-          }
-        }
+    return info;
+  }
+  writer.writeBlockStart(`interface App extends $.DefineRoutes<{`);
+  for (const route of routes.list) {
+    let routeDefFiles = "";
+    for (const file of routeFileIter(route)) {
+      const fileInfo = addFile(file);
+      fileInfo.routes.add(route);
+      if (routeDefFiles) {
+        routeDefFiles += ", ";
       }
+      routeDefFiles += fileInfo.id;
     }
+    writer.writeLines(`"${route.path.path}": [${routeDefFiles}];`);
   }
   for (const special of Object.values(routes.special)) {
-    routeTypes.set(special.page, []);
-  }
-  routesWriter.join();
-  const handlerWriter = writer.branch("handler");
-  const middlewareWriter = writer.branch("middleware");
-  const pageWriter = writer.branch("page");
-  const layoutWriter = writer.branch("layout");
-  for (const [file, types] of routeTypes) {
-    const modulePath = stripTsExtension(
-      normalizedRelativePath(outDir, file.filePath)
-    );
-    const routeType = `Run.Routes[${types.join(" | ")}]`;
-    switch (file.type) {
-      case RoutableFileTypes.Handler:
-        writeModuleDeclaration(handlerWriter, modulePath, routeType);
-        break;
-      case RoutableFileTypes.Middleware:
-        writeModuleDeclaration(middlewareWriter, modulePath, routeType);
-        break;
-      case RoutableFileTypes.Page:
-        writeModuleDeclaration(pageWriter, modulePath, routeType);
-        break;
-      case RoutableFileTypes.Layout:
-        writeModuleDeclaration(
-          layoutWriter,
-          modulePath,
-          routeType,
-          `
-  export interface Input extends Run.LayoutInput<typeof import("${modulePath}")> {}`
+    addFile(special.page);
+  }
+  writer.writeBlockEnd(`}> {}`).writeBlockEnd(`}`);
+  for (const fileType of Object.values(RoutableFileTypes)) {
+    const fileGroup = fileInfoByType.get(fileType);
+    if (!fileGroup) continue;
+    for (const info of fileGroup.values()) {
+      writer.writeLines("");
+      if (info.typeName) {
+        writer.writeLines(
+          `type ${info.id} = $.${info.typeName}<"${info.id}", typeof import("${info.modulePath}")>;`
         );
-        break;
-      case RoutableFileTypes.Error:
-        writeModuleDeclaration(
-          writer,
-          modulePath,
-          "globalThis.MarkoRun.Route",
-          `
+      }
+      if (fileType === RoutableFileTypes.Meta) continue;
+      writer.write(`declare module "${info.modulePath}" {`);
+      switch (fileType) {
+        case RoutableFileTypes.Layout:
+          writer.write(`
+  interface Input extends $.LayoutInput<${info.id}> {}`);
+          break;
+        case RoutableFileTypes.Error:
+          writer.write(`
   export interface Input {
     error: unknown;
-  }`
-        );
-        break;
-      case RoutableFileTypes.NotFound:
-        writeModuleDeclaration(writer, modulePath, "Run.Route");
-        break;
-    }
-  }
-  handlerWriter.join();
-  middlewareWriter.join();
-  pageWriter.join();
-  layoutWriter.join();
-  return writer.end();
-}
-function writeModuleDeclaration(writer, name, routeType, moduleTypes) {
-  writer.writeLines("").write(`declare module "${name}" {`);
-  if (moduleTypes) {
-    writer.write(moduleTypes);
+  }`);
+          break;
+      }
+      if (info.typeName) {
+        writer.write(`
+  const Run: $.Namespace<${info.id}>;
+  namespace Run {
+    type Context = $.ContextForFile<${info.id}>${info.typeName === "Template" ? " & Marko.Global" : ""};
   }
-  if (routeType) {
-    const isMarko = name.endsWith(".marko");
-    writer.write(`
+`);
+      }
+      writer.write(`
+  /** @deprecated use \`Run\` namespace instead */
   namespace MarkoRun {
     export { NotHandled, NotMatched, GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform };
-    export type Route = ${routeType};
-    export type Context = Run.MultiRouteContext<Route>${isMarko ? " & Marko.Global" : ""};
-    export type Handler = Run.HandlerLike<Route>;`);
-    for (const verb of httpVerbs) {
+    export type Route = ${info.routes.size ? `$.Routes["${[...info.routes].map((route) => route.path.path).join('" | "')}"]` : "globalThis.MarkoRun.Route"};
+    export type Context = ${info.modulePath.endsWith(".marko") ? "Run.Context" : "$.MultiRouteContext<Route>"};
+    export type Handler = $.HandlerLike<Route>;`);
+      for (const verb of httpVerbs) {
+        writer.write(`
+    export type ${verb.toUpperCase()} = $.HandlerLike<Route, "${verb.toUpperCase()}">;`);
+      }
       writer.write(`
-    export type ${verb.toUpperCase()} = Run.HandlerLike<Route, "${verb.toUpperCase()}">;`);
-    }
-    writer.write(`
-    /** @deprecated use \`((context, next) => { ... }) satisfies MarkoRun.Handler\` instead */
-    export const route: Run.HandlerTypeFn<Route>;
   }`);
-  }
-  writer.writeLines(`
+      writer.writeLines(`
 }`);
+    }
+  }
+  headWriter.join();
+  return writer.end();
 }
 function createRouteTrie(routes) {
   const root = {
@@ -1462,7 +1482,7 @@ async function buildRoutes(sources, outDir) {
               middleware: [],
               layouts: [...currentLayouts],
               page: file,
-              templateFilePath: currentLayouts.size ? path3.join(outDir, `${type}.marko`) : void 0
+              templateFilePath: path3.join(outDir, `${type}.marko`)
             };
             layoutsUsed = true;
           }
@@ -1495,7 +1515,7 @@ async function buildRoutes(sources, outDir) {
           meta: dir.files.get(RoutableFileTypes.Meta),
           page,
           handler,
-          templateFilePath: page && currentLayouts.size ? path3.join(outDir, key + ".marko") : void 0
+          templateFilePath: page && path3.join(outDir, key + ".marko")
         });
         layoutsUsed = !!page;
         for (const middleware2 of currentMiddleware) {
@@ -1534,7 +1554,7 @@ function createFSWalker(dir) {
     onDir,
     maxDepth = 50
   }) {
-    async function walk(dir2, depth) {
+    async function walk2(dir2, depth) {
       const onExit = onEnter == null ? void 0 : onEnter(dir2);
       if (onExit !== false) {
         const dirs = [];
@@ -1555,13 +1575,13 @@ function createFSWalker(dir) {
         }
         if ((onDir == null ? void 0 : onDir()) !== false && --depth > 0) {
           for (const entry of dirs) {
-            await walk(entry, depth);
+            await walk2(entry, depth);
           }
         }
         onExit == null ? void 0 : onExit();
       }
     }
-    await walk(
+    await walk2(
       {
         path: dir,
         name: path4.basename(dir)
@@ -1618,6 +1638,304 @@ var getExternalPluginOptions = (viteConfig) => getConfig(viteConfig, PluginConfi
 var setExternalPluginOptions = (viteConfig, value) => setConfig(viteConfig, PluginConfigKey, value);
 var getExternalAdapterOptions = (viteConfig) => getConfig(viteConfig, AdapterConfigKey);
 
+// src/runtime/url-builder.ts
+var encode = encodeURIComponent;
+var pathParts = /* @__PURE__ */ new Map();
+function parsePathParts(path7) {
+  let parts = pathParts.get(path7);
+  if (!parts) {
+    let lastEnd = 0;
+    let paramStart;
+    pathParts.set(path7, parts = [[]]);
+    while (lastEnd >= 0 && (paramStart = path7.indexOf("/$", lastEnd) + 1)) {
+      parts.push(path7.slice(lastEnd, paramStart++));
+      if (path7.charAt(paramStart) === "$") {
+        paramStart++;
+        lastEnd = -1;
+      } else {
+        lastEnd = path7.indexOf("/", paramStart);
+      }
+      parts[0].push(path7.slice(paramStart, lastEnd < 0 ? void 0 : lastEnd));
+    }
+    parts.push(lastEnd >= 0 ? path7.slice(lastEnd) : "");
+  }
+  return parts;
+}
+function joinHref(path7, options) {
+  let result = path7;
+  if (options.search) {
+    const query = "" + new URLSearchParams(options.search);
+    if (query) result += "?" + query;
+  }
+  if (options.hash) result += "#" + encode(options.hash);
+  return result;
+}
+function href(path7, ...[options]) {
+  return options ? "params" in options ? ((parts) => href_keys(parts, options, ...parts[0]))(
+    parsePathParts(path7)
+  ) : joinHref(path7, options) : path7;
+}
+function href_path(strings, ...params) {
+  let i = 0;
+  let j = 0;
+  let result = strings[i++];
+  if (!result || Array.isArray(result)) result = strings[i++];
+  while (i < strings.length) {
+    const param = params[j++];
+    result += (Array.isArray(param) ? param.map(encode).join("/") : encode(param)) + strings[i++];
+  }
+  return result;
+}
+function href_values(strings, options, ...params) {
+  return joinHref(href_path(strings, ...params), options);
+}
+function href_keys(strings, options, ...keys) {
+  return href_values(strings, options, ...keys.map((k) => options.params[k]));
+}
+
+// src/vite/utils/href-replace.ts
+function findHrefReplacements(code, ast) {
+  const replacements = [];
+  walk(ast, (node) => {
+    var _a, _b;
+    if (node.type !== "CallExpression") return;
+    const callee = node.callee;
+    if (callee.type !== "MemberExpression" || callee.computed || callee.object.type !== "Identifier" || callee.object.name !== "Run" || callee.property.type !== "Identifier" || callee.property.name !== "href") {
+      return;
+    }
+    const args = node.arguments;
+    if (args.length === 0 || args.length > 2 || args.some((a) => a.type === "SpreadElement")) {
+      return;
+    }
+    const pathString = (_a = tryStaticEval(args[0])) == null ? void 0 : _a.value;
+    if (typeof pathString !== "string") {
+      replacements.push({
+        helper: "href",
+        edits: [{ start: callee.start, end: callee.end, code: "href" }]
+      });
+      return;
+    }
+    if (args.length === 1) {
+      replacements.push({
+        helper: false,
+        edits: [
+          {
+            start: node.start,
+            end: node.end,
+            code: JSON.stringify(pathString)
+          }
+        ]
+      });
+      return;
+    }
+    const optionsNode = args[1];
+    const optionsObject = (_b = tryStaticEval(optionsNode)) == null ? void 0 : _b.value;
+    if (optionsObject && typeof optionsObject === "object" && !Array.isArray(optionsObject)) {
+      replacements.push({
+        helper: false,
+        edits: [
+          {
+            start: node.start,
+            end: node.end,
+            code: JSON.stringify(href(pathString, optionsObject))
+          }
+        ]
+      });
+      return;
+    }
+    const parsed = parsePathPattern(pathString);
+    if (optionsNode.type === "ObjectExpression") {
+      const params = tryExtractObjectProperty(optionsNode, "params");
+      if (params && parsed.params.every((p) => params.map.has(p))) {
+        const pathPart = buildPathTemplate(code, parsed, params.map);
+        if (params.only) {
+          replacements.push({
+            helper: "href_path",
+            edits: [
+              {
+                start: node.start,
+                end: node.end,
+                code: "href_path`" + pathPart + "`"
+              }
+            ]
+          });
+        } else {
+          const props = optionsNode.properties;
+          const remaining = props.filter((_, i) => i !== params.index);
+          if (remaining.length === 1 && remaining[0].type === "SpreadElement") {
+            replacements.push({
+              helper: "href_values",
+              edits: [
+                {
+                  start: node.start,
+                  end: remaining[0].argument.start,
+                  code: "href_values`${"
+                },
+                {
+                  start: remaining[0].argument.end,
+                  end: node.end,
+                  code: "}" + pathPart + "`"
+                }
+              ]
+            });
+          } else {
+            replacements.push({
+              helper: "href_values",
+              edits: [
+                {
+                  start: node.start,
+                  end: optionsNode.start,
+                  code: "href_values`${"
+                },
+                {
+                  start: optionsNode.end,
+                  end: node.end,
+                  code: "}" + pathPart + "`"
+                },
+                params.index < props.length - 1 ? {
+                  start: props[params.index].start,
+                  end: props[params.index + 1].start,
+                  code: ""
+                } : {
+                  start: props[params.index - 1].end,
+                  end: props[params.index].end,
+                  code: ""
+                }
+              ]
+            });
+          }
+        }
+        return;
+      }
+    }
+    replacements.push({
+      helper: "href_keys",
+      edits: [
+        { start: node.start, end: optionsNode.start, code: "href_keys`${" },
+        {
+          start: optionsNode.end,
+          end: node.end,
+          code: `}${buildPathTemplate(code, parsed)}\``
+        }
+      ]
+    });
+  });
+  return replacements;
+}
+function walk(node, visitor) {
+  if (!node || typeof node !== "object") return;
+  if (node.type) {
+    visitor(node);
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") {
+      continue;
+    }
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (item && typeof item === "object" && item.type) {
+          walk(item, visitor);
+        }
+      }
+    } else if (child && typeof child === "object" && child.type) {
+      walk(child, visitor);
+    }
+  }
+}
+function parsePathPattern(path7) {
+  const parts = parsePathParts(path7);
+  return { segments: parts.slice(1), params: parts[0] };
+}
+function buildPathTemplate(code, parsed, paramsMap) {
+  let template = "";
+  for (let i = 0; i < parsed.params.length; i++) {
+    template += parsed.segments[i];
+    if (paramsMap) {
+      const paramProp = paramsMap.get(parsed.params[i]);
+      const valueNode = paramProp.shorthand ? paramProp.key : paramProp.value;
+      template += "${" + code.slice(valueNode.start, valueNode.end) + "}";
+    } else {
+      template += '${"' + parsed.params[i] + '"}';
+    }
+  }
+  if (parsed.segments.length > parsed.params.length) {
+    template += parsed.segments[parsed.segments.length - 1];
+  }
+  return template;
+}
+function getStaticKey(prop) {
+  if (prop.computed) return null;
+  if (prop.key.type === "Identifier") return prop.key.name;
+  if (prop.key.type === "Literal" && typeof prop.key.value === "string")
+    return prop.key.value;
+  return null;
+}
+function tryStaticEval(node) {
+  switch (node.type) {
+    case "Literal":
+      return { value: node.value };
+    case "TemplateLiteral":
+      return node.expressions.length ? null : { value: node.quasis[0].value.cooked };
+    case "ObjectExpression": {
+      const value = {};
+      for (const prop of node.properties) {
+        if (prop.type === "SpreadElement" || prop.shorthand) return null;
+        const key = getStaticKey(prop);
+        if (!key) return null;
+        const val = tryStaticEval(prop.value);
+        if (!val) return null;
+        value[key] = val.value;
+      }
+      return { value };
+    }
+    case "ArrayExpression": {
+      const value = [];
+      for (const elem of node.elements) {
+        if (!elem || elem.type === "SpreadElement") return null;
+        const val = tryStaticEval(elem);
+        if (!val) return null;
+        value.push(val.value);
+      }
+      return { value };
+    }
+    case "UnaryExpression":
+      if (node.prefix && node.operator === "-") {
+        const arg = tryStaticEval(node.argument);
+        if (arg && typeof arg.value === "number") {
+          return { value: -arg.value };
+        }
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+function tryExtractObjectProperty(obj, propertyName) {
+  const props = obj.properties;
+  for (let i = props.length - 1; i >= 0; i--) {
+    const prop = props[i];
+    if (prop.type === "SpreadElement") return null;
+    if (getStaticKey(prop) !== propertyName) continue;
+    if (prop.value.type !== "ObjectExpression") return null;
+    const map = /* @__PURE__ */ new Map();
+    for (const paramProp of prop.value.properties) {
+      if (paramProp.type === "SpreadElement") return null;
+      const paramKey = getStaticKey(paramProp);
+      if (!paramKey) return null;
+      map.set(paramKey, paramProp);
+    }
+    let only = i === props.length - 1;
+    let j = i;
+    while (only && j--) {
+      const prop2 = props[j];
+      only = prop2.type === "Property" && getStaticKey(prop2) === propertyName;
+    }
+    return { map, index: i, only };
+  }
+  return null;
+}
+
 // src/vite/utils/log.ts
 import zlib from "node:zlib";
 import Table from "cli-table3";
@@ -1902,7 +2220,7 @@ function markoRun(opts = {}) {
     var _a, _b;
     routeMarkoApiCache ?? (routeMarkoApiCache = /* @__PURE__ */ new Map());
     if (!routeMarkoApiCache.has(route)) {
-      const markoAPI = route.templateFilePath && ((_b = (_a = await loadModule(context, normalizePath(route.layouts[0].filePath))) == null ? void 0 : _a.meta) == null ? void 0 : _b.markoAPI);
+      const markoAPI = route.layouts.length ? (_b = (_a = await loadModule(context, normalizePath(route.layouts[0].filePath))) == null ? void 0 : _a.meta) == null ? void 0 : _b.markoAPI : void 0;
       routeMarkoApiCache.set(route, markoAPI);
       return markoAPI;
     }
@@ -1924,7 +2242,6 @@ function markoRun(opts = {}) {
   let buildVirtualFilesResult;
   function buildVirtualFiles() {
     return buildVirtualFilesResult ?? (buildVirtualFilesResult = (async () => {
-      var _a, _b;
       virtualFiles.clear();
       if (fs3.existsSync(resolvedRoutesDir)) {
         routes = await buildRoutes(
@@ -1949,9 +2266,8 @@ function markoRun(opts = {}) {
       entryTemplates = /* @__PURE__ */ new Set();
       entryTemplateImporters = /* @__PURE__ */ new Set();
       for (const route of routes.list) {
-        const routeEntryPath = route.templateFilePath || ((_a = route.page) == null ? void 0 : _a.filePath);
-        if (routeEntryPath) {
-          entryTemplates.add(normalizePath(routeEntryPath));
+        if (route.templateFilePath) {
+          entryTemplates.add(normalizePath(route.templateFilePath));
         }
         for (const middleware of route.middleware) {
           entryTemplateImporters.add(normalizePath(middleware.filePath));
@@ -1965,9 +2281,8 @@ function markoRun(opts = {}) {
         );
       }
       for (const route of Object.values(routes.special)) {
-        const routeEntryPath = route.templateFilePath || ((_b = route.page) == null ? void 0 : _b.filePath);
-        if (routeEntryPath) {
-          entryTemplates.add(normalizePath(routeEntryPath));
+        if (route.templateFilePath) {
+          entryTemplates.add(normalizePath(route.templateFilePath));
         }
       }
       if (routes.middleware.length) {
@@ -2022,7 +2337,8 @@ function markoRun(opts = {}) {
               route.templateFilePath,
               renderRouteTemplate(
                 route,
-                await getMarkoApiForRoute(context, route)
+                await getMarkoApiForRoute(context, route),
+                !isBuild
               )
             );
           }
@@ -2032,18 +2348,17 @@ function markoRun(opts = {}) {
           );
         }
         for (const route of Object.values(routes2.special)) {
-          if (route.templateFilePath) {
-            fs3.mkdirSync(path6.dirname(route.templateFilePath), {
-              recursive: true
-            });
-            fs3.writeFileSync(
-              route.templateFilePath,
-              renderRouteTemplate(
-                route,
-                await getMarkoApiForRoute(context, route)
-              )
-            );
-          }
+          fs3.mkdirSync(path6.dirname(route.templateFilePath), {
+            recursive: true
+          });
+          fs3.writeFileSync(
+            route.templateFilePath,
+            renderRouteTemplate(
+              route,
+              await getMarkoApiForRoute(context, route),
+              !isBuild
+            )
+          );
         }
         if (routes2.middleware.length) {
           for (const middleware of routes2.middleware) {
@@ -2348,6 +2663,48 @@ function markoRun(opts = {}) {
     {
       name: `${PLUGIN_NAME_PREFIX}:post`,
       enforce: "post",
+      async transform(code) {
+        if (!isBuild || isSSRBuild || !code.includes("Run.href")) {
+          return;
+        }
+        try {
+          const replacements = findHrefReplacements(
+            code,
+            this.parse(code, { lang: "js" })
+          );
+          if (replacements.length) {
+            const helpers = /* @__PURE__ */ new Set();
+            const s = new RolldownMagicString(code);
+            for (const { helper, edits } of replacements) {
+              for (const { start, end, code: code2 } of edits) {
+                if (code2) {
+                  s.overwrite(start, end, code2);
+                } else {
+                  s.remove(start, end);
+                }
+              }
+              if (helper) {
+                helpers.add(helper);
+              }
+            }
+            if (helpers.size) {
+              s.prepend(
+                `import { ${[...helpers].join(", ")} } from "virtual:marko-run/runtime/url-builder";`
+              );
+            }
+            return {
+              code: s
+            };
+          }
+          return null;
+        } catch {
+          return {
+            code: new RolldownMagicString(code).prepend(
+              'import "virtual:marko-run/runtime/client";'
+            )
+          };
+        }
+      },
       generateBundle(options, bundle) {
         if (options.sourcemap && options.sourcemap !== "inline") {
           for (const key of Object.keys(bundle)) {