@constela/start 1.1.0 → 1.2.0

package/dist/chunk-6AN7W7KZ.js

@@ -0,0 +1,2553 @@
+import {
+  generateHydrationScript,
+  renderPage,
+  wrapHtml
+} from "./chunk-PUTC5BCP.js";
+
+// src/router/file-router.ts
+import fg from "fast-glob";
+import { existsSync, statSync } from "fs";
+import { join } from "path";
+function filePathToPattern(filePath, _routesDir) {
+  let normalized = filePath.replace(/\\/g, "/");
+  normalized = normalized.replace(/\.(ts|tsx|js|jsx|json)$/, "");
+  const segments = normalized.split("/");
+  const processedSegments = segments.map((segment) => {
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      return "*";
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      const paramName = segment.slice(1, -1);
+      return `:${paramName}`;
+    }
+    return segment;
+  });
+  if (processedSegments.at(-1) === "index") {
+    processedSegments.pop();
+  }
+  const path = "/" + processedSegments.join("/");
+  if (path === "/") {
+    return "/";
+  }
+  return path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function extractParams(filePath) {
+  const params = [];
+  const normalized = filePath.replace(/\\/g, "/");
+  const regex = /\[(?:\.\.\.)?([^\]]+)\]/g;
+  let match;
+  while ((match = regex.exec(normalized)) !== null) {
+    const paramName = match[1];
+    if (paramName !== void 0) {
+      params.push(paramName);
+    }
+  }
+  return params;
+}
+function determineRouteType(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const fileName = normalized.split("/").pop() ?? "";
+  if (fileName.startsWith("_middleware.")) {
+    return "middleware";
+  }
+  if (normalized.startsWith("api/") || normalized.includes("/api/")) {
+    return "api";
+  }
+  return "page";
+}
+function shouldIncludeRoute(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const fileName = normalized.split("/").pop() ?? "";
+  if (fileName.endsWith(".d.ts")) {
+    return false;
+  }
+  if (fileName.startsWith("_") && !fileName.startsWith("_middleware.")) {
+    return false;
+  }
+  return true;
+}
+async function scanRoutes(routesDir) {
+  if (!existsSync(routesDir)) {
+    throw new Error(`Routes directory does not exist: ${routesDir}`);
+  }
+  const stats = statSync(routesDir);
+  if (!stats.isDirectory()) {
+    throw new Error(`Routes path is not a directory: ${routesDir}`);
+  }
+  const files = await fg("**/*.{ts,tsx,js,jsx,json}", {
+    cwd: routesDir,
+    ignore: ["node_modules/**", "**/*.d.ts"],
+    onlyFiles: true,
+    followSymbolicLinks: false
+  });
+  const routes = [];
+  for (const filePath of files) {
+    if (!shouldIncludeRoute(filePath)) {
+      continue;
+    }
+    const route = {
+      file: join(routesDir, filePath),
+      pattern: filePathToPattern(filePath, routesDir),
+      type: determineRouteType(filePath),
+      params: extractParams(filePath)
+    };
+    routes.push(route);
+  }
+  routes.sort((a, b) => {
+    return compareRoutes(a, b);
+  });
+  return routes;
+}
+function compareRoutes(a, b) {
+  if (a.type === "middleware" && b.type !== "middleware") return -1;
+  if (b.type === "middleware" && a.type !== "middleware") return 1;
+  const segmentsA = a.pattern.split("/").filter(Boolean);
+  const segmentsB = b.pattern.split("/").filter(Boolean);
+  const minLen = Math.min(segmentsA.length, segmentsB.length);
+  for (let i = 0; i < minLen; i++) {
+    const segA = segmentsA[i] ?? "";
+    const segB = segmentsB[i] ?? "";
+    const typeA = getSegmentType(segA);
+    const typeB = getSegmentType(segB);
+    if (typeA !== typeB) {
+      return typeA - typeB;
+    }
+    if (typeA === 0 && segA !== segB) {
+      return segA.localeCompare(segB);
+    }
+  }
+  if (segmentsA.length !== segmentsB.length) {
+    return segmentsA.length - segmentsB.length;
+  }
+  return a.pattern.localeCompare(b.pattern);
+}
+function getSegmentType(segment) {
+  if (segment === "*") return 2;
+  if (segment.startsWith(":")) return 1;
+  return 0;
+}
+
+// src/static/index.ts
+import { extname, join as join2, normalize, resolve } from "path";
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
+var MIME_TYPES = {
+  // Images
+  ".ico": "image/x-icon",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  // Fonts
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+  // Web assets
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".json": "application/json",
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".xml": "application/xml",
+  // Other
+  ".pdf": "application/pdf",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".map": "application/json"
+};
+var DEFAULT_MIME_TYPE = "application/octet-stream";
+function isPathSafe(pathname) {
+  if (!pathname) {
+    return false;
+  }
+  if (!pathname.startsWith("/")) {
+    return false;
+  }
+  if (pathname.includes("\\")) {
+    return false;
+  }
+  if (pathname.includes("//")) {
+    return false;
+  }
+  if (pathname.includes("\0") || pathname.includes("%00")) {
+    return false;
+  }
+  let decoded;
+  try {
+    decoded = pathname;
+    let prevDecoded = "";
+    while (decoded !== prevDecoded) {
+      prevDecoded = decoded;
+      decoded = decodeURIComponent(decoded);
+    }
+  } catch {
+    return false;
+  }
+  if (decoded.includes("\0")) {
+    return false;
+  }
+  if (decoded.includes("..")) {
+    return false;
+  }
+  const segments = decoded.split("/").filter(Boolean);
+  for (const segment of segments) {
+    if (segment.startsWith(".")) {
+      return false;
+    }
+  }
+  return true;
+}
+function getMimeType(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return MIME_TYPES[ext] ?? DEFAULT_MIME_TYPE;
+}
+function hasObviousAttackPattern(pathname) {
+  if (!pathname) {
+    return true;
+  }
+  if (!pathname.startsWith("/")) {
+    return true;
+  }
+  if (pathname.includes("\\")) {
+    return true;
+  }
+  if (pathname.includes("//")) {
+    return true;
+  }
+  if (pathname.includes("\0") || pathname.includes("%00")) {
+    return true;
+  }
+  let decoded;
+  try {
+    decoded = pathname;
+    let prevDecoded = "";
+    while (decoded !== prevDecoded) {
+      prevDecoded = decoded;
+      decoded = decodeURIComponent(decoded);
+    }
+  } catch {
+    return true;
+  }
+  if (decoded.includes("\0")) {
+    return true;
+  }
+  const segments = decoded.split("/").filter(Boolean);
+  for (const segment of segments) {
+    if (segment.startsWith(".") && segment !== "..") {
+      return true;
+    }
+  }
+  if (decoded.startsWith("/..")) {
+    return true;
+  }
+  return false;
+}
+function resolveStaticFile(pathname, publicDir) {
+  if (hasObviousAttackPattern(pathname)) {
+    return {
+      exists: false,
+      filePath: null,
+      mimeType: null,
+      error: "path_traversal"
+    };
+  }
+  let decodedPathname;
+  try {
+    decodedPathname = decodeURIComponent(pathname);
+  } catch {
+    return {
+      exists: false,
+      filePath: null,
+      mimeType: null,
+      error: "path_traversal"
+    };
+  }
+  const relativePath = decodedPathname.slice(1);
+  const resolvedPath = normalize(join2(publicDir, relativePath));
+  const absolutePublicDir = resolve(publicDir);
+  const publicDirWithSep = absolutePublicDir.endsWith("/") ? absolutePublicDir : absolutePublicDir + "/";
+  if (!resolvedPath.startsWith(publicDirWithSep) && resolvedPath !== absolutePublicDir) {
+    return {
+      exists: false,
+      filePath: null,
+      mimeType: null,
+      error: "outside_public"
+    };
+  }
+  const mimeType = getMimeType(resolvedPath);
+  let exists = false;
+  if (existsSync2(resolvedPath)) {
+    try {
+      const stats = statSync2(resolvedPath);
+      exists = stats.isFile();
+    } catch {
+      exists = false;
+    }
+  }
+  return {
+    exists,
+    filePath: resolvedPath,
+    mimeType
+  };
+}
+
+// src/build/mdx.ts
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkMdx from "remark-mdx";
+import remarkGfm from "remark-gfm";
+import matter from "gray-matter";
+function lit(value) {
+  return { expr: "lit", value };
+}
+function textNode(value) {
+  return { kind: "text", value: lit(value) };
+}
+function elementNode(tag, props, children) {
+  const node = { kind: "element", tag };
+  if (props && Object.keys(props).length > 0) {
+    node.props = props;
+  }
+  if (children && children.length > 0) {
+    node.children = children;
+  }
+  return node;
+}
+function codeNode(language, content) {
+  return {
+    kind: "code",
+    language: lit(language),
+    content: lit(content)
+  };
+}
+function wrapNodes(nodes) {
+  if (nodes.length === 0) {
+    return elementNode("div");
+  }
+  if (nodes.length === 1 && nodes[0]) {
+    return nodes[0];
+  }
+  return elementNode("div", void 0, nodes);
+}
+function isCustomComponent(name) {
+  if (!name) return false;
+  return /^[A-Z]/.test(name);
+}
+var DISALLOWED_PATTERNS = [
+  /\bfunction\b/i,
+  /\b(eval|Function|setTimeout|setInterval)\b/,
+  /\bimport\b/,
+  /\brequire\b/,
+  /\bfetch\b/,
+  /\bwindow\b/,
+  /\bdocument\b/,
+  /\bglobal\b/,
+  /\bprocess\b/,
+  /\b__proto__\b/,
+  /\bconstructor\b/,
+  /\bprototype\b/
+];
+function isSafeLiteral(value) {
+  return !DISALLOWED_PATTERNS.some((pattern) => pattern.test(value));
+}
+function safeEvalLiteral(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+  }
+  if (!isSafeLiteral(value)) {
+    return null;
+  }
+  try {
+    const fn = new Function(`return (${value});`);
+    return fn();
+  } catch {
+    return null;
+  }
+}
+function parseAttributeValue(attr) {
+  if (attr.value === null) {
+    return lit(true);
+  }
+  if (typeof attr.value === "string") {
+    return lit(attr.value);
+  }
+  if (attr.value.type === "mdxJsxAttributeValueExpression") {
+    const exprValue = attr.value.value.trim();
+    if (exprValue === "true") return lit(true);
+    if (exprValue === "false") return lit(false);
+    if (exprValue === "null") return lit(null);
+    const num = Number(exprValue);
+    if (!Number.isNaN(num)) return lit(num);
+    if (exprValue.startsWith("[") || exprValue.startsWith("{")) {
+      const parsed = safeEvalLiteral(exprValue);
+      if (parsed !== null && parsed !== void 0) {
+        return lit(parsed);
+      }
+    }
+    return lit(exprValue);
+  }
+  return lit(null);
+}
+function transformNode(node, ctx) {
+  switch (node.type) {
+    case "heading":
+      return elementNode(
+        `h${node.depth}`,
+        void 0,
+        transformChildren(node.children, ctx)
+      );
+    case "paragraph":
+      return elementNode("p", void 0, transformChildren(node.children, ctx));
+    case "text":
+      return textNode(node.value);
+    case "emphasis":
+      return elementNode("em", void 0, transformChildren(node.children, ctx));
+    case "strong":
+      return elementNode("strong", void 0, transformChildren(node.children, ctx));
+    case "link": {
+      const props = {
+        href: lit(node.url)
+      };
+      if (node["title"]) {
+        props["title"] = lit(node["title"]);
+      }
+      return elementNode("a", props, transformChildren(node.children, ctx));
+    }
+    case "inlineCode":
+      return elementNode("code", void 0, [textNode(node.value)]);
+    case "code": {
+      const lang = node.lang || "text";
+      return codeNode(lang, node.value);
+    }
+    case "blockquote":
+      return elementNode("blockquote", void 0, transformChildren(node.children, ctx));
+    case "list": {
+      const tag = node.ordered ? "ol" : "ul";
+      const props = node.ordered && node.start != null && node.start !== 1 ? { start: lit(node.start) } : void 0;
+      return elementNode(tag, props, transformChildren(node.children, ctx));
+    }
+    case "listItem": {
+      const children = [];
+      for (const child of node.children) {
+        if (child.type === "paragraph") {
+          children.push(...transformChildren(child.children, ctx));
+        } else {
+          const transformed = transformNode(child, ctx);
+          if (transformed) {
+            if (Array.isArray(transformed)) {
+              children.push(...transformed);
+            } else {
+              children.push(transformed);
+            }
+          }
+        }
+      }
+      return elementNode("li", void 0, children);
+    }
+    case "thematicBreak":
+      return elementNode("hr");
+    case "break":
+      return elementNode("br");
+    case "image": {
+      const props = {
+        src: lit(node.url)
+      };
+      if (node["alt"]) {
+        props["alt"] = lit(node["alt"]);
+      }
+      if (node["title"]) {
+        props["title"] = lit(node["title"]);
+      }
+      return elementNode("img", props);
+    }
+    case "html":
+      return textNode(node.value);
+    // MDX JSX elements
+    case "mdxJsxFlowElement":
+    case "mdxJsxTextElement":
+      return transformJsxElement(node, ctx);
+    // MDX expressions
+    case "mdxFlowExpression":
+    case "mdxTextExpression": {
+      const exprNode = node;
+      const value = exprNode.value.trim();
+      if (value === "") return null;
+      if (value === "true") return textNode("true");
+      if (value === "false") return textNode("false");
+      if (value === "null") return textNode("null");
+      const num = Number(value);
+      if (!Number.isNaN(num)) return textNode(String(num));
+      return textNode(value);
+    }
+    // GFM extensions
+    case "table": {
+      const rows = node.children;
+      if (!rows || rows.length === 0) {
+        return elementNode("table", void 0, []);
+      }
+      const headerRow = rows[0];
+      const headerCells = headerRow.children.map(
+        (cell) => elementNode("th", void 0, transformChildren(cell.children, ctx))
+      );
+      const thead = elementNode("thead", void 0, [
+        elementNode("tr", void 0, headerCells)
+      ]);
+      const bodyRows = rows.slice(1).map((row) => {
+        const cells = row.children.map(
+          (cell) => elementNode("td", void 0, transformChildren(cell.children, ctx))
+        );
+        return elementNode("tr", void 0, cells);
+      });
+      const tbody = bodyRows.length > 0 ? elementNode("tbody", void 0, bodyRows) : null;
+      const tableChildren = [thead];
+      if (tbody) {
+        tableChildren.push(tbody);
+      }
+      return elementNode("table", void 0, tableChildren);
+    }
+    // tableRow and tableCell are handled within the 'table' case above
+    case "delete":
+      return elementNode("del", void 0, transformChildren(node.children, ctx));
+    default:
+      return null;
+  }
+}
+function transformJsxElement(node, ctx) {
+  const name = node.name;
+  if (!name) {
+    const children2 = transformChildren(node.children, ctx);
+    return wrapNodes(children2);
+  }
+  if (isCustomComponent(name)) {
+    const def = ctx.components[name];
+    if (!def) {
+      throw new Error(`Undefined component: ${name}`);
+    }
+    const props2 = {};
+    for (const attr of node.attributes) {
+      if (attr.type === "mdxJsxAttribute") {
+        props2[attr.name] = parseAttributeValue(attr);
+      }
+    }
+    const children2 = transformChildren(node.children, ctx);
+    return applyComponentView(def.view, props2, children2);
+  }
+  const props = {};
+  for (const attr of node.attributes) {
+    if (attr.type === "mdxJsxAttribute") {
+      props[attr.name] = parseAttributeValue(attr);
+    }
+  }
+  const children = transformChildren(node.children, ctx);
+  return elementNode(name, props, children);
+}
+function substituteExpression(expr, props) {
+  const exprAny = expr;
+  if (exprAny.expr === "param") {
+    const paramExpr = expr;
+    const propValue = props[paramExpr.name];
+    if (!propValue) {
+      return { expr: "lit", value: null };
+    }
+    if (paramExpr.path && propValue.expr === "var") {
+      const varExpr = propValue;
+      return {
+        expr: "var",
+        name: varExpr.name,
+        path: paramExpr.path
+      };
+    }
+    return propValue;
+  }
+  if (expr.expr === "bin") {
+    const binExpr = expr;
+    return {
+      expr: "bin",
+      op: binExpr.op,
+      left: substituteExpression(binExpr.left, props),
+      right: substituteExpression(binExpr.right, props)
+    };
+  }
+  if (expr.expr === "not") {
+    const notExpr = expr;
+    return {
+      expr: "not",
+      operand: substituteExpression(notExpr.operand, props)
+    };
+  }
+  if (expr.expr === "cond") {
+    const condExpr = expr;
+    return {
+      expr: "cond",
+      if: substituteExpression(condExpr.if, props),
+      then: substituteExpression(condExpr.then, props),
+      else: substituteExpression(condExpr.else, props)
+    };
+  }
+  if (expr.expr === "get") {
+    const getExpr = expr;
+    return {
+      expr: "get",
+      base: substituteExpression(getExpr.base, props),
+      path: getExpr.path
+    };
+  }
+  return expr;
+}
+function applyComponentView(view, props, children) {
+  return substituteInNode(view, props, children);
+}
+function substituteInNode(node, props, children) {
+  switch (node.kind) {
+    case "each": {
+      const eachNode = node;
+      const result = {
+        kind: "each",
+        items: substituteExpression(eachNode.items, props),
+        as: eachNode.as,
+        body: substituteInNode(eachNode.body, props, children)
+      };
+      if (eachNode.index) {
+        result.index = eachNode.index;
+      }
+      if (eachNode.key) {
+        result.key = substituteExpression(eachNode.key, props);
+      }
+      return result;
+    }
+    case "text": {
+      const textNode2 = node;
+      return {
+        kind: "text",
+        value: substituteExpression(textNode2.value, props)
+      };
+    }
+    case "if": {
+      const ifNode = node;
+      const result = {
+        kind: "if",
+        condition: substituteExpression(ifNode.condition, props),
+        then: substituteInNode(ifNode.then, props, children)
+      };
+      if (ifNode.else) {
+        result.else = substituteInNode(ifNode.else, props, children);
+      }
+      return result;
+    }
+    case "element": {
+      const elem = node;
+      const newProps = {};
+      if (elem.props) {
+        for (const [key, value] of Object.entries(elem.props)) {
+          newProps[key] = substituteExpression(value, props);
+        }
+      }
+      let newChildren;
+      if (elem.children) {
+        newChildren = [];
+        for (const child of elem.children) {
+          if (child.kind === "slot") {
+            newChildren.push(...children);
+          } else {
+            newChildren.push(substituteInNode(child, props, children));
+          }
+        }
+      }
+      return elementNode(
+        elem.tag,
+        Object.keys(newProps).length > 0 ? newProps : void 0,
+        newChildren && newChildren.length > 0 ? newChildren : void 0
+      );
+    }
+    case "markdown":
+    case "code":
+      return node;
+    default:
+      return node;
+  }
+}
+function transformChildren(children, ctx) {
+  const result = [];
+  for (const child of children) {
+    const transformed = transformNode(child, ctx);
+    if (transformed) {
+      if (Array.isArray(transformed)) {
+        result.push(...transformed);
+      } else {
+        result.push(transformed);
+      }
+    }
+  }
+  return result;
+}
+function transformRoot(root, ctx) {
+  const nodes = transformChildren(root.children, ctx);
+  return wrapNodes(nodes);
+}
+async function mdxToConstela(source, options) {
+  const { content, data: _frontmatter } = matter(source);
+  const processor = unified().use(remarkParse).use(remarkGfm).use(remarkMdx);
+  const tree = processor.parse(content);
+  const ctx = {
+    components: options?.components ?? {}
+  };
+  const view = transformRoot(tree, ctx);
+  return {
+    version: "1.0",
+    state: {},
+    actions: {},
+    view
+  };
+}
+async function mdxContentToNode(content, options) {
+  const processor = unified().use(remarkParse).use(remarkGfm).use(remarkMdx);
+  const tree = processor.parse(content);
+  const ctx = {
+    components: options?.components ?? {}
+  };
+  return transformRoot(tree, ctx);
+}
+
+// src/data/loader.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { basename, extname as extname2, join as join3 } from "path";
+import fg2 from "fast-glob";
+var mdxContentToNode2 = mdxContentToNode;
+function resolveJsonRefs(json) {
+  const cloned = JSON.parse(JSON.stringify(json));
+  const resolvingPaths = /* @__PURE__ */ new Set();
+  return resolveRefsRecursive(cloned, cloned, resolvingPaths);
+}
+function resolveRefsRecursive(current, root, resolvingPaths) {
+  if (current === null || typeof current !== "object") {
+    return current;
+  }
+  if (Array.isArray(current)) {
+    return current.map((item) => resolveRefsRecursive(item, root, resolvingPaths));
+  }
+  const obj = current;
+  if ("$ref" in obj && Object.keys(obj).length === 1) {
+    const refPath = obj["$ref"];
+    if (typeof refPath !== "string") {
+      throw new Error(`Invalid $ref: value must be a string`);
+    }
+    if (!refPath.startsWith("#")) {
+      throw new Error(`Invalid $ref: path must start with # (got "${refPath}")`);
+    }
+    if (resolvingPaths.has(refPath)) {
+      throw new Error(`Circular $ref detected: "${refPath}"`);
+    }
+    resolvingPaths.add(refPath);
+    try {
+      const resolved = resolveJsonPointer(root, refPath);
+      return resolveRefsRecursive(resolved, root, resolvingPaths);
+    } finally {
+      resolvingPaths.delete(refPath);
+    }
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key] = resolveRefsRecursive(value, root, resolvingPaths);
+  }
+  return result;
+}
+function resolveJsonPointer(root, pointer) {
+  const path = pointer.slice(1);
+  if (path === "" || path === "/") {
+    return root;
+  }
+  if (!path.startsWith("/")) {
+    throw new Error(`Invalid $ref: path after # must be empty or start with / (got "${pointer}")`);
+  }
+  const segments = path.slice(1).split("/").map(decodeJsonPointerSegment);
+  let current = root;
+  for (const segment of segments) {
+    if (current === null || current === void 0) {
+      throw new Error(`Invalid $ref: path "${pointer}" references null/undefined`);
+    }
+    if (Array.isArray(current)) {
+      const index = parseInt(segment, 10);
+      if (isNaN(index) || index < 0 || index >= current.length) {
+        throw new Error(`Invalid $ref: array index "${segment}" out of bounds in "${pointer}"`);
+      }
+      current = current[index];
+    } else if (typeof current === "object") {
+      const obj = current;
+      if (!(segment in obj)) {
+        throw new Error(`Invalid $ref: property "${segment}" not found in "${pointer}"`);
+      }
+      current = obj[segment];
+    } else {
+      throw new Error(`Invalid $ref: cannot access "${segment}" on primitive value in "${pointer}"`);
+    }
+  }
+  return current;
+}
+function decodeJsonPointerSegment(segment) {
+  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function parseYaml(content) {
+  const result = {};
+  const lines = content.split("\n");
+  const stack = [{ indent: -2, obj: result }];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line || line.trim() === "" || line.trim().startsWith("#")) continue;
+    const arrayMatch = line.match(/^(\s*)-\s*(.*)$/);
+    if (arrayMatch) {
+      const [, indentStr2, rest] = arrayMatch;
+      const indent2 = indentStr2?.length ?? 0;
+      while (stack.length > 1 && indent2 <= stack[stack.length - 1].indent) {
+        stack.pop();
+      }
+      const parent = stack[stack.length - 1];
+      const key2 = parent.key;
+      if (key2) {
+        if (!Array.isArray(parent.obj[key2])) {
+          parent.obj[key2] = [];
+        }
+        const arr = parent.obj[key2];
+        const objMatch = rest?.match(/^([\w-]+):\s*(.*)$/);
+        if (objMatch) {
+          const [, k, v] = objMatch;
+          const newObj = {};
+          if (v?.trim()) {
+            newObj[k] = parseValue(v);
+          }
+          arr.push(newObj);
+          stack.push({ indent: indent2, obj: newObj, key: k, isArray: true });
+        } else if (rest?.trim()) {
+          arr.push(parseValue(rest.trim()));
+        }
+      }
+      continue;
+    }
+    const match = line.match(/^(\s*)([\w-]+):\s*(.*)$/);
+    if (!match) continue;
+    const [, indentStr, key, value] = match;
+    const indent = indentStr?.length ?? 0;
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    let targetObj;
+    const currentTop = stack[stack.length - 1];
+    if (currentTop.isArray) {
+      targetObj = currentTop.obj;
+    } else if (currentTop.key) {
+      if (!currentTop.obj[currentTop.key]) {
+        currentTop.obj[currentTop.key] = {};
+      }
+      targetObj = currentTop.obj[currentTop.key];
+    } else {
+      targetObj = currentTop.obj;
+    }
+    if (value?.trim() === "" || value === void 0) {
+      const newObj = {};
+      targetObj[key] = newObj;
+      stack.push({ indent, obj: targetObj, key });
+    } else {
+      targetObj[key] = parseValue(value);
+    }
+  }
+  return result;
+}
+function parseValue(value) {
+  const trimmed = value.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null" || trimmed === "~") return null;
+  if (/^-?\d+$/.test(trimmed)) return parseInt(trimmed, 10);
+  if (/^-?\d+\.\d+$/.test(trimmed)) return parseFloat(trimmed);
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function loadComponentDefinitions(baseDir, componentsPath) {
+  const fullPath = join3(baseDir, componentsPath);
+  const resolvedBase = join3(baseDir, "");
+  const resolvedPath = join3(fullPath, "");
+  if (!resolvedPath.startsWith(resolvedBase)) {
+    throw new Error(`Invalid component path: path traversal detected`);
+  }
+  if (!existsSync3(fullPath)) {
+    throw new Error(`MDX components file not found: ${fullPath}`);
+  }
+  const content = readFileSync(fullPath, "utf-8");
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(`Invalid JSON in MDX components file: ${fullPath}`);
+  }
+}
+async function transformMdx(content, file, options) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  let frontmatter = {};
+  let mdxContent;
+  if (match) {
+    frontmatter = parseYaml(match[1]);
+    mdxContent = match[2].trim();
+  } else {
+    mdxContent = content.trim();
+  }
+  const compiledContent = await mdxContentToNode(
+    mdxContent,
+    options?.components ? { components: options.components } : void 0
+  );
+  const fmSlug = frontmatter["slug"];
+  const slug = typeof fmSlug === "string" ? fmSlug : basename(file, extname2(file));
+  return {
+    file,
+    raw: content,
+    frontmatter,
+    content: compiledContent,
+    slug
+  };
+}
+function transformYaml(content) {
+  return parseYaml(content);
+}
+function transformCsv(content) {
+  const lines = content.trim().split("\n");
+  if (lines.length === 0) return [];
+  const headerLine = lines[0];
+  const headers = parseCSVLine(headerLine);
+  const result = [];
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "") continue;
+    const values = parseCSVLine(line);
+    const row = {};
+    for (let j = 0; j < headers.length; j++) {
+      row[headers[j].trim()] = (values[j] ?? "").trim();
+    }
+    result.push(row);
+  }
+  return result;
+}
+function parseCSVLine(line) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    } else if (char === "," && !inQuotes) {
+      result.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  result.push(current);
+  return result;
+}
+function applyTransform(content, transform, filename) {
+  if (!transform) {
+    if (filename.endsWith(".json")) {
+      const parsed = JSON.parse(content);
+      return resolveJsonRefs(parsed);
+    }
+    return content;
+  }
+  switch (transform) {
+    case "mdx":
+      throw new Error("MDX transform for single files is not supported via loadFile. Use loadGlob instead.");
+    case "yaml":
+      return transformYaml(content);
+    case "csv":
+      return transformCsv(content);
+    default:
+      return content;
+  }
+}
+async function loadGlob(baseDir, pattern, transform, options) {
+  const files = await fg2(pattern, { cwd: baseDir });
+  if (transform === "mdx") {
+    const results2 = [];
+    for (const file of files) {
+      const fullPath = join3(baseDir, file);
+      const content = readFileSync(fullPath, "utf-8");
+      const transformed = await transformMdx(content, file, options);
+      results2.push(transformed);
+    }
+    return results2;
+  }
+  const results = [];
+  for (const file of files) {
+    const fullPath = join3(baseDir, file);
+    const content = readFileSync(fullPath, "utf-8");
+    results.push({
+      file,
+      raw: content
+    });
+  }
+  return results;
+}
+async function loadFile(baseDir, filePath, transform) {
+  const fullPath = join3(baseDir, filePath);
+  if (!existsSync3(fullPath)) {
+    throw new Error(`File not found: ${fullPath}`);
+  }
+  const content = readFileSync(fullPath, "utf-8");
+  return applyTransform(content, transform, filePath);
+}
+async function loadApi(url, transform) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`api request failed: ${response.status} ${response.statusText}`);
+    }
+    if (transform === "csv") {
+      const text = await response.text();
+      return transformCsv(text);
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("api request failed")) {
+      throw error;
+    }
+    throw new Error(`Network error: ${error.message}`);
+  }
+}
+function evaluateParamExpression(expr, item) {
+  switch (expr.expr) {
+    case "lit":
+      return String(expr.value);
+    case "var":
+      if (expr.name === "item") {
+        if (expr.path) {
+          return getNestedValue(item, expr.path);
+        }
+        return String(item);
+      }
+      return "";
+    case "get":
+      if (expr.base.expr === "var" && expr.base.name === "item") {
+        return getNestedValue(item, expr.path);
+      }
+      return "";
+    default:
+      return "";
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return "";
+    if (typeof current !== "object") return "";
+    current = current[part];
+  }
+  return current !== void 0 && current !== null ? String(current) : "";
+}
+async function generateStaticPaths(data, staticPathsDef) {
+  const paths = [];
+  for (const item of data) {
+    const params = {};
+    for (const [paramName, paramExpr] of Object.entries(staticPathsDef.params)) {
+      params[paramName] = evaluateParamExpression(paramExpr, item);
+    }
+    paths.push({ params, data: item });
+  }
+  return paths;
+}
+var DataLoader = class {
+  cache = /* @__PURE__ */ new Map();
+  componentCache = /* @__PURE__ */ new Map();
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  /**
+   * Resolve components from string path or import reference
+   */
+  resolveComponents(ref, imports) {
+    if (typeof ref === "string") {
+      if (this.componentCache.has(ref)) {
+        return this.componentCache.get(ref);
+      }
+      const defs = loadComponentDefinitions(this.projectRoot, ref);
+      this.componentCache.set(ref, defs);
+      return defs;
+    }
+    if (ref.expr === "import") {
+      if (!imports) {
+        throw new Error(`Import context required for component reference "${ref.name}"`);
+      }
+      const imported = imports[ref.name];
+      if (!imported || typeof imported !== "object") {
+        throw new Error(`Component import "${ref.name}" not found or invalid`);
+      }
+      return imported;
+    }
+    return {};
+  }
+  /**
+   * Load a single data source
+   */
+  async loadDataSource(name, dataSource, context) {
+    if (this.cache.has(name)) {
+      return this.cache.get(name);
+    }
+    let componentDefs;
+    if (dataSource.transform === "mdx" && dataSource.components) {
+      componentDefs = this.resolveComponents(
+        dataSource.components,
+        context?.imports
+      );
+    }
+    let data;
+    switch (dataSource.type) {
+      case "glob":
+        if (!dataSource.pattern) {
+          throw new Error(`Glob data source '${name}' requires pattern`);
+        }
+        data = await loadGlob(
+          this.projectRoot,
+          dataSource.pattern,
+          dataSource.transform,
+          componentDefs ? { components: componentDefs } : void 0
+        );
+        break;
+      case "file":
+        if (!dataSource.path) {
+          throw new Error(`File data source '${name}' requires path`);
+        }
+        data = await loadFile(this.projectRoot, dataSource.path, dataSource.transform);
+        break;
+      case "api":
+        if (!dataSource.url) {
+          throw new Error(`API data source '${name}' requires url`);
+        }
+        data = await loadApi(dataSource.url, dataSource.transform);
+        break;
+      default:
+        throw new Error(`Unknown data source type: ${dataSource.type}`);
+    }
+    this.cache.set(name, data);
+    return data;
+  }
+  /**
+   * Load all data sources
+   */
+  async loadAllDataSources(dataSources) {
+    const result = {};
+    for (const [name, source] of Object.entries(dataSources)) {
+      result[name] = await this.loadDataSource(name, source);
+    }
+    return result;
+  }
+  /**
+   * Clear cache for a specific data source or all caches
+   */
+  clearCache(name) {
+    if (name) {
+      this.cache.delete(name);
+    } else {
+      this.cache.clear();
+    }
+  }
+  /**
+   * Clear all cache entries
+   */
+  clearAllCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get the current cache size
+   */
+  getCacheSize() {
+    return this.cache.size;
+  }
+};
+
+// src/layout/resolver.ts
+import { existsSync as existsSync5, statSync as statSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join5, basename as basename2, dirname } from "path";
+import fg3 from "fast-glob";
+import { isLayoutProgram } from "@constela/core";
+
+// src/utils/import-resolver.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { join as join4, resolve as resolve2 } from "path";
+async function resolveImports(pageDir, imports, projectRoot) {
+  if (!imports || Object.keys(imports).length === 0) {
+    return {};
+  }
+  const resolved = {};
+  const resolvedRoot = projectRoot ? resolve2(projectRoot) : null;
+  for (const [name, importPath] of Object.entries(imports)) {
+    const fullPath = join4(pageDir, importPath);
+    if (resolvedRoot) {
+      const resolvedPath = resolve2(fullPath);
+      if (!resolvedPath.startsWith(resolvedRoot + "/") && resolvedPath !== resolvedRoot) {
+        throw new Error(`Invalid import path "${name}": path traversal detected`);
+      }
+    }
+    if (!existsSync4(fullPath)) {
+      throw new Error(`Import "${name}" not found: ${fullPath}`);
+    }
+    let content;
+    try {
+      content = readFileSync2(fullPath, "utf-8");
+    } catch (error) {
+      throw new Error(`Failed to read import "${name}": ${fullPath}`);
+    }
+    try {
+      const parsed = JSON.parse(content);
+      resolved[name] = resolveJsonRefs(parsed);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error(`Invalid JSON in import "${name}": ${fullPath}`);
+      }
+      throw error;
+    }
+  }
+  return resolved;
+}
+
+// src/layout/resolver.ts
+async function scanLayouts(layoutsDir) {
+  if (!existsSync5(layoutsDir)) {
+    throw new Error(`Layouts directory does not exist: ${layoutsDir}`);
+  }
+  const stat2 = statSync3(layoutsDir);
+  if (!stat2.isDirectory()) {
+    throw new Error(`Path is not a directory: ${layoutsDir}`);
+  }
+  const files = await fg3(["**/*.ts", "**/*.tsx", "**/*.json"], {
+    cwd: layoutsDir,
+    ignore: ["**/_*", "**/*.d.ts"]
+  });
+  const layouts = files.filter((file) => {
+    const name = basename2(file);
+    if (name.startsWith("_")) return false;
+    if (name.endsWith(".d.ts")) return false;
+    if (!name.endsWith(".ts") && !name.endsWith(".tsx") && !name.endsWith(".json")) return false;
+    return true;
+  }).map((file) => {
+    const name = basename2(file).replace(/\.(tsx?|json)$/, "");
+    return {
+      name,
+      file: join5(layoutsDir, file)
+    };
+  });
+  return layouts;
+}
+function resolveLayout(layoutName, layouts) {
+  return layouts.find((l) => l.name === layoutName);
+}
+async function loadLayout(layoutFile) {
+  try {
+    let exported;
+    if (layoutFile.endsWith(".json")) {
+      const content = readFileSync3(layoutFile, "utf-8");
+      const parsed = JSON.parse(content);
+      const importsValue = parsed["imports"];
+      if (importsValue && typeof importsValue === "object" && Object.keys(importsValue).length > 0) {
+        const layoutDir = dirname(layoutFile);
+        const resolvedImports = await resolveImports(
+          layoutDir,
+          importsValue
+        );
+        exported = { ...parsed, importData: resolvedImports };
+      } else {
+        exported = parsed;
+      }
+    } else {
+      const module = await import(layoutFile);
+      exported = module.default || module;
+    }
+    if (!isLayoutProgram(exported)) {
+      throw new Error(`File is not a valid layout: ${layoutFile}`);
+    }
+    return exported;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("not a valid layout")) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.includes("not found")) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.includes("Invalid JSON")) {
+      throw error;
+    }
+    throw new Error(`Failed to load layout: ${layoutFile}`);
+  }
+}
+var LayoutResolver = class {
+  layoutsDir;
+  layouts = [];
+  loadedLayouts = /* @__PURE__ */ new Map();
+  initialized = false;
+  constructor(layoutsDir) {
+    this.layoutsDir = layoutsDir;
+  }
+  /**
+   * Initialize the resolver by scanning the layouts directory
+   */
+  async initialize() {
+    try {
+      this.layouts = await scanLayouts(this.layoutsDir);
+      this.initialized = true;
+    } catch {
+      this.layouts = [];
+      this.initialized = true;
+    }
+  }
+  /**
+   * Check if a layout exists
+   */
+  hasLayout(name) {
+    return this.layouts.some((l) => l.name === name);
+  }
+  /**
+   * Get a layout by name
+   *
+   * @param name - Layout name
+   * @returns The layout program or undefined if not found
+   */
+  async getLayout(name) {
+    const cached = this.loadedLayouts.get(name);
+    if (cached) {
+      return cached;
+    }
+    const scanned = resolveLayout(name, this.layouts);
+    if (!scanned) {
+      return void 0;
+    }
+    const layout = await loadLayout(scanned.file);
+    this.loadedLayouts.set(name, layout);
+    return layout;
+  }
+  /**
+   * Compose a page with its layout
+   *
+   * @param page - Page program to compose
+   * @returns Composed program (or original if no layout)
+   * @throws Error if specified layout is not found
+   */
+  async composeWithLayout(page) {
+    const layoutName = page.route?.layout;
+    if (!layoutName) {
+      return page;
+    }
+    if (!this.hasLayout(layoutName)) {
+      const available = this.layouts.map((l) => l.name).join(", ");
+      throw new Error(
+        `Layout '${layoutName}' not found. Available layouts: ${available || "none"}`
+      );
+    }
+    const layout = await this.getLayout(layoutName);
+    if (!layout) {
+      throw new Error(`Layout '${layoutName}' not found`);
+    }
+    return page;
+  }
+  /**
+   * Get all scanned layouts
+   */
+  getAll() {
+    return [...this.layouts];
+  }
+};
+
+// src/dev/server.ts
+import { createServer } from "http";
+import { createReadStream } from "fs";
+import { join as join7, isAbsolute } from "path";
+import { createServer as createViteServer } from "vite";
+
+// src/json-page-loader.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, join as join6, relative, resolve as resolve3 } from "path";
+function validateVersion(version) {
+  if (version !== "1.0") {
+    throw new Error(`Unsupported version: ${version}. Only version "1.0" is supported.`);
+  }
+}
+function extractRouteParams(path) {
+  const params = [];
+  const segments = path.split("/");
+  for (const segment of segments) {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1).replace("*", "");
+      params.push(paramName);
+    }
+  }
+  return params;
+}
+function getNestedValue2(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return "";
+    if (typeof current !== "object") return "";
+    current = current[part];
+  }
+  return current !== void 0 && current !== null ? String(current) : "";
+}
+function evaluateParamExpression2(expr, item) {
+  switch (expr.expr) {
+    case "lit":
+      return String(expr.value);
+    case "var":
+      if (expr.name === "item") {
+        if (expr.path) {
+          return getNestedValue2(item, expr.path);
+        }
+        return String(item);
+      }
+      return "";
+    case "get":
+      if (expr.base.expr === "var" && expr.base.name === "item") {
+        return getNestedValue2(item, expr.path);
+      }
+      return "";
+    default:
+      return "";
+  }
+}
+function compileWidget(widgetJson) {
+  return {
+    version: widgetJson.version || "1.0",
+    state: convertState(widgetJson.state),
+    actions: convertActions(widgetJson.actions),
+    view: convertViewNode(widgetJson.view)
+  };
+}
+async function loadWidgets(pageDir, widgets, baseDir) {
+  if (!widgets || widgets.length === 0) {
+    return [];
+  }
+  const resolvedBase = resolve3(baseDir);
+  const compiledWidgets = [];
+  for (const widget of widgets) {
+    const widgetPath = join6(pageDir, widget.src);
+    const resolvedWidgetPath = resolve3(widgetPath);
+    if (!resolvedWidgetPath.startsWith(resolvedBase + "/") && resolvedWidgetPath !== resolvedBase) {
+      throw new Error(`Invalid widget path "${widget.id}": path traversal detected`);
+    }
+    if (!existsSync6(widgetPath)) {
+      throw new Error(`Widget file not found: ${resolvedWidgetPath}`);
+    }
+    let widgetContent;
+    try {
+      widgetContent = readFileSync4(widgetPath, "utf-8");
+    } catch {
+      throw new Error(`Failed to read widget file "${widget.id}": ${resolvedWidgetPath}`);
+    }
+    let widgetJson;
+    try {
+      widgetJson = JSON.parse(widgetContent);
+    } catch {
+      throw new Error(`Invalid JSON in widget file "${widget.id}": ${resolvedWidgetPath}`);
+    }
+    const program = compileWidget(widgetJson);
+    compiledWidgets.push({
+      id: widget.id,
+      program
+    });
+  }
+  return compiledWidgets;
+}
+function normalizeDataSourcePatterns(projectRoot, pageDir, dataSources) {
+  if (!dataSources || Object.keys(dataSources).length === 0) {
+    return {};
+  }
+  const resolvedProjectRoot = resolve3(projectRoot);
+  const result = {};
+  for (const [name, source] of Object.entries(dataSources)) {
+    const normalizedSource = { ...source };
+    if (source.type === "glob" && source.pattern) {
+      if (source.pattern.startsWith("./") || source.pattern.startsWith("../")) {
+        const absolutePath = resolve3(pageDir, source.pattern);
+        if (!absolutePath.startsWith(resolvedProjectRoot + "/") && absolutePath !== resolvedProjectRoot) {
+          throw new Error(
+            `Invalid pattern "${source.pattern}": path traversal outside project root detected`
+          );
+        }
+        normalizedSource.pattern = relative(resolvedProjectRoot, absolutePath);
+      }
+    }
+    if (source.type === "file" && source.path) {
+      if (source.path.startsWith("./") || source.path.startsWith("../")) {
+        const absolutePath = resolve3(pageDir, source.path);
+        if (!absolutePath.startsWith(resolvedProjectRoot + "/") && absolutePath !== resolvedProjectRoot) {
+          throw new Error(
+            `Invalid path "${source.path}": path traversal outside project root detected`
+          );
+        }
+        normalizedSource.path = relative(resolvedProjectRoot, absolutePath);
+      }
+    }
+    result[name] = normalizedSource;
+  }
+  return result;
+}
+async function loadJsonPage(baseDir, pagePath) {
+  const filePath = join6(baseDir, pagePath);
+  const resolvedBase = resolve3(baseDir);
+  const resolvedPath = resolve3(filePath);
+  if (!resolvedPath.startsWith(resolvedBase + "/") && resolvedPath !== resolvedBase) {
+    throw new Error(`Invalid path: path traversal detected`);
+  }
+  if (!existsSync6(filePath)) {
+    throw new Error(`Page file not found: ${filePath}`);
+  }
+  let content;
+  try {
+    content = readFileSync4(filePath, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to read page file: ${filePath}`);
+  }
+  let page;
+  try {
+    page = JSON.parse(content);
+  } catch {
+    throw new Error(`Invalid JSON in page file: ${filePath}`);
+  }
+  if (!("version" in page) || page.version === void 0) {
+    throw new Error(`Missing required field "version" in page: ${filePath}`);
+  }
+  if (!("view" in page) || page.view === void 0) {
+    throw new Error(`Missing required field "view" in page: ${filePath}`);
+  }
+  validateVersion(page.version);
+  const pageDir = dirname2(filePath);
+  const resolvedImports = await resolveImports(pageDir, page.imports, baseDir);
+  const normalizedData = normalizeDataSourcePatterns(baseDir, pageDir, page.data);
+  const loadedData = await loadPageData(baseDir, normalizedData, { imports: resolvedImports });
+  const widgets = await loadWidgets(pageDir, page.widgets, baseDir);
+  return {
+    filePath,
+    page,
+    resolvedImports,
+    loadedData,
+    widgets
+  };
+}
+async function loadPageData(baseDir, dataSources, context) {
+  if (!dataSources || Object.keys(dataSources).length === 0) {
+    return {};
+  }
+  const loader = new DataLoader(baseDir);
+  const result = {};
+  for (const [name, source] of Object.entries(dataSources)) {
+    result[name] = await loader.loadDataSource(name, source, context);
+  }
+  return result;
+}
+async function generateStaticPathsFromPage(pageConfig, loadedData) {
+  if (!pageConfig.getStaticPaths) {
+    return [];
+  }
+  const { source, params } = pageConfig.getStaticPaths;
+  const sourceData = loadedData[source];
+  if (sourceData === void 0) {
+    throw new Error(`Data source "${source}" not found for getStaticPaths`);
+  }
+  if (!Array.isArray(sourceData)) {
+    throw new Error(`Data source "${source}" must be an array for getStaticPaths`);
+  }
+  const paths = [];
+  for (const item of sourceData) {
+    const extractedParams = {};
+    for (const [paramName, paramExpr] of Object.entries(params)) {
+      extractedParams[paramName] = evaluateParamExpression2(paramExpr, item);
+    }
+    paths.push({
+      params: extractedParams,
+      data: item
+    });
+  }
+  return paths;
+}
+function substituteParamExpr(expr, props) {
+  if (expr.expr === "param") {
+    const propValue = props[expr.name];
+    if (propValue) {
+      if (expr.path) {
+        return {
+          expr: "get",
+          base: propValue,
+          path: expr.path
+        };
+      }
+      return propValue;
+    }
+    return expr;
+  }
+  if (expr.expr === "bin") {
+    return {
+      ...expr,
+      left: substituteParamExpr(expr.left, props),
+      right: substituteParamExpr(expr.right, props)
+    };
+  }
+  if (expr.expr === "not") {
+    return {
+      ...expr,
+      operand: substituteParamExpr(expr.operand, props)
+    };
+  }
+  if (expr.expr === "cond") {
+    return {
+      ...expr,
+      if: substituteParamExpr(expr.if, props),
+      then: substituteParamExpr(expr.then, props),
+      else: substituteParamExpr(expr.else, props)
+    };
+  }
+  if (expr.expr === "get") {
+    return {
+      ...expr,
+      base: substituteParamExpr(expr.base, props)
+    };
+  }
+  if (expr.expr === "index") {
+    return {
+      ...expr,
+      base: substituteParamExpr(expr.base, props),
+      key: substituteParamExpr(expr.key, props)
+    };
+  }
+  return expr;
+}
+function substituteParamsInNode(node, props, components) {
+  switch (node.kind) {
+    case "text":
+      return {
+        ...node,
+        value: substituteParamExpr(node.value, props)
+      };
+    case "element": {
+      const elementNode2 = node;
+      const newProps = elementNode2.props ? Object.fromEntries(
+        Object.entries(elementNode2.props).map(([key, value]) => {
+          if (value && typeof value === "object" && "event" in value) {
+            return [key, value];
+          }
+          return [key, substituteParamExpr(value, props)];
+        })
+      ) : void 0;
+      const newChildren = elementNode2.children ? elementNode2.children.map((child) => substituteParamsInNode(child, props, components)) : void 0;
+      return {
+        ...elementNode2,
+        props: newProps,
+        children: newChildren
+      };
+    }
+    case "if": {
+      const ifNode = node;
+      const result = {
+        kind: "if",
+        condition: substituteParamExpr(ifNode.condition, props),
+        then: substituteParamsInNode(ifNode.then, props, components)
+      };
+      if (ifNode.else) {
+        result.else = substituteParamsInNode(ifNode.else, props, components);
+      }
+      return result;
+    }
+    case "each": {
+      const eachNode = node;
+      const result = {
+        kind: "each",
+        items: substituteParamExpr(eachNode.items, props),
+        as: eachNode.as,
+        body: substituteParamsInNode(eachNode.body, props, components)
+      };
+      if (eachNode.index) {
+        result.index = eachNode.index;
+      }
+      if (eachNode.key) {
+        result.key = substituteParamExpr(eachNode.key, props);
+      }
+      return result;
+    }
+    case "component": {
+      const componentNode = node;
+      const substitutedProps = componentNode.props ? Object.fromEntries(
+        Object.entries(componentNode.props).map(([key, value]) => [
+          key,
+          substituteParamExpr(value, props)
+        ])
+      ) : {};
+      return expandComponent(
+        { ...componentNode, props: substitutedProps },
+        components
+      );
+    }
+    case "markdown":
+      return {
+        ...node,
+        content: substituteParamExpr(node.content, props)
+      };
+    case "code":
+      return {
+        ...node,
+        language: substituteParamExpr(node.language, props),
+        content: substituteParamExpr(node.content, props)
+      };
+    case "slot":
+      return node;
+    default:
+      return node;
+  }
+}
+function expandComponent(node, components) {
+  const componentDef = components[node.name];
+  if (!componentDef) {
+    throw new Error(`Component "${node.name}" not found in component definitions`);
+  }
+  const props = node.props || {};
+  return substituteParamsInNode(componentDef.view, props, components);
+}
+function convertViewNode(node, components = {}) {
+  switch (node.kind) {
+    case "component": {
+      const expanded = expandComponent(node, components);
+      return convertViewNode(expanded, components);
+    }
+    case "element": {
+      const elementNode2 = node;
+      const convertedChildren = elementNode2.children ? elementNode2.children.map((child) => convertViewNode(child, components)) : void 0;
+      return {
+        ...elementNode2,
+        children: convertedChildren
+      };
+    }
+    case "if": {
+      const ifNode = node;
+      return {
+        ...ifNode,
+        then: convertViewNode(ifNode.then, components),
+        else: ifNode.else ? convertViewNode(ifNode.else, components) : void 0
+      };
+    }
+    case "each": {
+      const eachNode = node;
+      return {
+        ...eachNode,
+        body: convertViewNode(eachNode.body, components)
+      };
+    }
+    default:
+      return node;
+  }
+}
+function convertActions(actions) {
+  if (!actions) {
+    return {};
+  }
+  if (typeof actions === "object" && !Array.isArray(actions) && Object.keys(actions).length === 0) {
+    return {};
+  }
+  if (Array.isArray(actions)) {
+    if (actions.length === 0) {
+      return {};
+    }
+    const result2 = {};
+    for (const action of actions) {
+      const actionDef = action;
+      result2[actionDef.name] = {
+        name: actionDef.name,
+        steps: actionDef.steps
+      };
+    }
+    return result2;
+  }
+  const result = {};
+  for (const [name, action] of Object.entries(actions)) {
+    const actionDef = action;
+    result[name] = {
+      name,
+      steps: actionDef.steps ?? []
+    };
+  }
+  return result;
+}
+function convertState(state) {
+  if (!state || Object.keys(state).length === 0) {
+    return {};
+  }
+  const result = {};
+  for (const [name, field] of Object.entries(state)) {
+    const stateField = field;
+    result[name] = {
+      type: stateField.type,
+      initial: stateField.initial
+    };
+  }
+  return result;
+}
+async function convertToCompiledProgram(pageInfo) {
+  const { page, resolvedImports, loadedData } = pageInfo;
+  const components = page.components || {};
+  const program = {
+    version: "1.0",
+    state: convertState(page.state),
+    actions: convertActions(page.actions),
+    view: convertViewNode(page.view, components)
+  };
+  if (page.route) {
+    program.route = {
+      path: page.route.path,
+      params: extractRouteParams(page.route.path)
+    };
+    if (page.route.layout) {
+      program.route.layout = page.route.layout;
+    }
+    if (page.route.layoutParams) {
+      program.route.layoutParams = page.route.layoutParams;
+    }
+    if (page.route.meta) {
+      program.route.meta = {};
+      for (const [key, value] of Object.entries(page.route.meta)) {
+        program.route.meta[key] = { expr: "lit", value };
+      }
+    }
+  }
+  const hasImports = Object.keys(resolvedImports).length > 0;
+  const hasData = Object.keys(loadedData).length > 0;
+  if (hasImports || hasData) {
+    program.importData = {
+      ...resolvedImports,
+      ...loadedData
+    };
+  }
+  if (page.lifecycle) {
+    program.lifecycle = page.lifecycle;
+  }
+  return program;
+}
+var JsonPageLoader = class {
+  projectRoot;
+  cache = /* @__PURE__ */ new Map();
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  /**
+   * Load a JSON page with full resolution
+   */
+  async loadPage(pagePath) {
+    if (this.cache.has(pagePath)) {
+      return this.cache.get(pagePath);
+    }
+    const pageInfo = await loadJsonPage(this.projectRoot, pagePath);
+    this.cache.set(pagePath, pageInfo);
+    return pageInfo;
+  }
+  /**
+   * Get static paths for a page
+   */
+  async getStaticPaths(pagePath) {
+    const pageInfo = await this.loadPage(pagePath);
+    return generateStaticPathsFromPage(pageInfo.page, pageInfo.loadedData);
+  }
+  /**
+   * Compile a page to CompiledProgram
+   */
+  async compile(pagePath, options) {
+    const pageInfo = await this.loadPage(pagePath);
+    const program = await convertToCompiledProgram(pageInfo);
+    if (options?.params) {
+    }
+    return program;
+  }
+  /**
+   * Clear cache for a specific page or all pages
+   */
+  clearCache(pagePath) {
+    if (pagePath) {
+      this.cache.delete(pagePath);
+    } else {
+      this.cache.clear();
+    }
+  }
+};
+
+// src/dev/server.ts
+import { analyzeLayoutPass, transformLayoutPass, composeLayoutWithPage } from "@constela/compiler";
+var DEFAULT_PORT = 3e3;
+var DEFAULT_HOST = "localhost";
+var DEFAULT_PUBLIC_DIR = "public";
+var DEFAULT_ROUTES_DIR = "src/pages";
+function matchRoute(url, routes) {
+  const normalizedUrl = url === "/" ? "/" : url.replace(/\/$/, "");
+  const urlSegments = normalizedUrl.split("/").filter(Boolean);
+  for (const route of routes) {
+    if (route.type !== "page") {
+      continue;
+    }
+    const patternSegments = route.pattern.split("/").filter(Boolean);
+    const params = {};
+    const hasCatchAll = patternSegments.includes("*");
+    if (hasCatchAll) {
+      const catchAllIndex = patternSegments.indexOf("*");
+      let matched = true;
+      for (let i = 0; i < catchAllIndex; i++) {
+        const patternSeg = patternSegments[i];
+        const urlSeg = urlSegments[i];
+        if (patternSeg === void 0 || urlSeg === void 0) {
+          matched = false;
+          break;
+        }
+        if (patternSeg.startsWith(":")) {
+          const paramName = patternSeg.slice(1);
+          params[paramName] = urlSeg;
+        } else if (patternSeg !== urlSeg) {
+          matched = false;
+          break;
+        }
+      }
+      if (matched && urlSegments.length >= catchAllIndex) {
+        const catchAllParamName = route.params.find((p) => {
+          return true;
+        });
+        if (catchAllParamName) {
+          const remainingSegments = urlSegments.slice(catchAllIndex);
+          params[catchAllParamName] = remainingSegments.join("/");
+        }
+        return { route, params };
+      }
+    } else {
+      if (patternSegments.length !== urlSegments.length) {
+        continue;
+      }
+      let matched = true;
+      for (let i = 0; i < patternSegments.length; i++) {
+        const patternSeg = patternSegments[i];
+        const urlSeg = urlSegments[i];
+        if (patternSeg === void 0 || urlSeg === void 0) {
+          matched = false;
+          break;
+        }
+        if (patternSeg.startsWith(":")) {
+          const paramName = patternSeg.slice(1);
+          params[paramName] = urlSeg;
+        } else if (patternSeg !== urlSeg) {
+          matched = false;
+          break;
+        }
+      }
+      if (matched) {
+        return { route, params };
+      }
+    }
+  }
+  return null;
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function extractMdxContentSlot(loadedData, dataSourceName, routeParams) {
+  const dataSource = loadedData[dataSourceName];
+  if (!Array.isArray(dataSource)) {
+    return void 0;
+  }
+  const slug = routeParams["slug"] || "index";
+  const item = dataSource.find(
+    (entry) => typeof entry === "object" && entry !== null && "slug" in entry && entry.slug === slug
+  );
+  if (!item || typeof item !== "object" || !("content" in item)) {
+    return void 0;
+  }
+  return { "mdx-content": item.content };
+}
+async function createDevServer(options = {}) {
+  const {
+    port = DEFAULT_PORT,
+    host = DEFAULT_HOST,
+    routesDir = DEFAULT_ROUTES_DIR,
+    publicDir = join7(process.cwd(), DEFAULT_PUBLIC_DIR),
+    layoutsDir,
+    css
+  } = options;
+  let httpServer = null;
+  let actualPort = port;
+  let viteServer = null;
+  if (css) {
+    viteServer = await createViteServer({
+      root: process.cwd(),
+      server: { middlewareMode: true },
+      appType: "custom",
+      logLevel: "silent"
+    });
+  }
+  const absoluteRoutesDir = isAbsolute(routesDir) ? routesDir : join7(process.cwd(), routesDir);
+  let routes = [];
+  try {
+    routes = await scanRoutes(absoluteRoutesDir);
+  } catch {
+    routes = [];
+  }
+  let layoutResolver = null;
+  if (layoutsDir) {
+    const absoluteLayoutsDir = isAbsolute(layoutsDir) ? layoutsDir : join7(process.cwd(), layoutsDir);
+    layoutResolver = new LayoutResolver(absoluteLayoutsDir);
+    await layoutResolver.initialize();
+  }
+  const devServer = {
+    get port() {
+      return actualPort;
+    },
+    async listen() {
+      return new Promise((resolve4, reject) => {
+        httpServer = createServer(async (req, res) => {
+          const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+          const pathname = url.pathname;
+          if (viteServer) {
+            await new Promise((resolveMiddleware) => {
+              viteServer.middlewares(req, res, () => {
+                resolveMiddleware();
+              });
+            });
+            if (res.writableEnded) {
+              return;
+            }
+          }
+          const staticResult = resolveStaticFile(pathname, publicDir);
+          if (staticResult.error === "path_traversal" || staticResult.error === "outside_public") {
+            res.writeHead(403, { "Content-Type": "text/plain" });
+            res.end("Forbidden");
+            return;
+          }
+          if (staticResult.exists && staticResult.filePath && staticResult.mimeType) {
+            res.writeHead(200, { "Content-Type": staticResult.mimeType });
+            const stream = createReadStream(staticResult.filePath);
+            stream.pipe(res);
+            stream.on("error", () => {
+              if (!res.headersSent) {
+                res.writeHead(500, { "Content-Type": "text/plain" });
+              }
+              res.end("Internal Server Error");
+            });
+            return;
+          }
+          const match = matchRoute(pathname, routes);
+          if (match) {
+            try {
+              const projectRoot = process.cwd();
+              const pageLoader = new JsonPageLoader(projectRoot);
+              const relativePath = match.route.file.startsWith(projectRoot) ? match.route.file.slice(projectRoot.length + 1) : match.route.file;
+              const pageInfo = await pageLoader.loadPage(relativePath);
+              const program = await convertToCompiledProgram(pageInfo);
+              let composedProgram = program;
+              const widgets = pageInfo.widgets.map((w) => ({ id: w.id, program: w.program }));
+              if (program.route?.layout && layoutResolver) {
+                const layoutProgram = await layoutResolver.getLayout(program.route.layout);
+                if (layoutProgram) {
+                  const analysis = analyzeLayoutPass(layoutProgram);
+                  if (analysis.ok) {
+                    const compiledLayout = transformLayoutPass(layoutProgram, analysis.context);
+                    const layoutParams = program.route?.layoutParams;
+                    const slots = extractMdxContentSlot(pageInfo.loadedData, "docs", match.params);
+                    composedProgram = composeLayoutWithPage(
+                      compiledLayout,
+                      program,
+                      layoutParams,
+                      slots
+                    );
+                  }
+                }
+              }
+              const ssrContext = {
+                url: pathname,
+                params: match.params,
+                query: url.searchParams
+              };
+              const content = await renderPage(composedProgram, ssrContext);
+              const routeContext = {
+                params: match.params,
+                query: Object.fromEntries(url.searchParams.entries()),
+                path: pathname
+              };
+              const hydrationScript = generateHydrationScript(composedProgram, widgets, routeContext);
+              const cssHead = css ? (Array.isArray(css) ? css : [css]).map((p) => `<link rel="stylesheet" href="/${p}">`).join("\n") : "";
+              const themeState = composedProgram.state?.["theme"];
+              const initialTheme = themeState?.initial;
+              const importMap = {
+                "@constela/runtime": "/node_modules/@constela/runtime/dist/index.js",
+                "@constela/core": "/node_modules/@constela/core/dist/index.js",
+                "@constela/compiler": "/node_modules/@constela/compiler/dist/index.js",
+                "marked": "/node_modules/marked/lib/marked.esm.js",
+                "monaco-editor": "/node_modules/monaco-editor/esm/vs/editor/editor.api.js"
+              };
+              const html = wrapHtml(content, hydrationScript, cssHead, {
+                ...initialTheme ? { theme: initialTheme } : {},
+                importMap
+              });
+              res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+              res.end(html);
+              return;
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error);
+              const errorStack = error instanceof Error ? error.stack : "";
+              res.writeHead(500, { "Content-Type": "text/html; charset=utf-8" });
+              res.end(`<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Server Error</title>
+<style>
+body { font-family: system-ui, sans-serif; padding: 2rem; background: #1a1a1a; color: #fff; }
+h1 { color: #ff6b6b; }
+pre { background: #2d2d2d; padding: 1rem; border-radius: 4px; overflow-x: auto; }
+</style>
+</head>
+<body>
+<h1>Server Error</h1>
+<p>${escapeHtml(errorMessage)}</p>
+<pre>${escapeHtml(errorStack ?? "")}</pre>
+</body>
+</html>`);
+              return;
+            }
+          }
+          res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(`<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>404 Not Found</title>
+<style>
+body { font-family: system-ui, sans-serif; padding: 2rem; text-align: center; }
+h1 { color: #666; }
+</style>
+</head>
+<body>
+<h1>404 Not Found</h1>
+<p>The page <code>${escapeHtml(pathname)}</code> could not be found.</p>
+</body>
+</html>`);
+        });
+        httpServer.on("error", (err) => {
+          reject(err);
+        });
+        httpServer.listen(port, host, () => {
+          const address = httpServer?.address();
+          if (address) {
+            actualPort = address.port;
+          }
+          resolve4();
+        });
+      });
+    },
+    async close() {
+      if (viteServer) {
+        await viteServer.close();
+        viteServer = null;
+      }
+      return new Promise((resolve4, reject) => {
+        if (!httpServer) {
+          resolve4();
+          return;
+        }
+        httpServer.closeAllConnections();
+        httpServer.close((err) => {
+          if (err) {
+            reject(err);
+          } else {
+            httpServer = null;
+            resolve4();
+          }
+        });
+      });
+    }
+  };
+  return devServer;
+}
+
+// src/build/index.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { mkdir as mkdir2, writeFile, cp, readdir } from "fs/promises";
+import { join as join9, dirname as dirname5, relative as relative2, basename as basename4 } from "path";
+
+// src/build/bundler.ts
+import * as esbuild from "esbuild";
+import { mkdir } from "fs/promises";
+import { join as join8, dirname as dirname4 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname4(fileURLToPath(import.meta.url));
+async function bundleRuntime(options) {
+  const entryContent = `
+    export { hydrateApp, createApp } from '@constela/runtime';
+  `;
+  const outFile = join8(options.outDir, "_constela", "runtime.js");
+  await mkdir(dirname4(outFile), { recursive: true });
+  try {
+    await esbuild.build({
+      stdin: {
+        contents: entryContent,
+        resolveDir: __dirname,
+        loader: "ts"
+      },
+      bundle: true,
+      format: "esm",
+      target: "es2020",
+      platform: "browser",
+      outfile: outFile,
+      minify: options.minify ?? true,
+      treeShaking: true
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to bundle runtime to ${outFile}: ${message}`);
+  }
+  return "/_constela/runtime.js";
+}
+
+// src/build/index.ts
+function isDynamicRoute(pattern) {
+  return pattern.includes(":") || pattern.includes("*");
+}
+function getOutputPath(filePath, outDir) {
+  const withoutExt = filePath.replace(/\.(json|ts|tsx|js|jsx)$/, "");
+  if (withoutExt === "index" || withoutExt.endsWith("/index")) {
+    return join9(outDir, withoutExt + ".html");
+  }
+  return join9(outDir, withoutExt, "index.html");
+}
+function paramsToOutputPath(basePattern, params, outDir) {
+  let path = basePattern;
+  for (const [key, value] of Object.entries(params)) {
+    path = path.replace(`:${key}`, value);
+    path = path.replace("*", value);
+  }
+  const relativePath = path.startsWith("/") ? path.slice(1) : path;
+  if (relativePath === "") {
+    return join9(outDir, "index.html");
+  }
+  return join9(outDir, relativePath, "index.html");
+}
+async function loadGetStaticPaths(pageFile) {
+  const dir = dirname5(pageFile);
+  const baseName = basename4(pageFile, ".json");
+  const pathsFile = join9(dir, `${baseName}.paths.ts`);
+  if (!existsSync7(pathsFile)) {
+    return null;
+  }
+  try {
+    const content = readFileSync5(pathsFile, "utf-8");
+    const pathsMatch = content.match(/paths:\s*\[([\s\S]*?)\]/);
+    if (!pathsMatch) {
+      throw new Error(`Invalid getStaticPaths format in ${pathsFile}`);
+    }
+    const pathsContent = pathsMatch[1];
+    const paramsRegex = /\{\s*params:\s*\{([^}]+)\}\s*\}/g;
+    const paths = [];
+    let match;
+    while ((match = paramsRegex.exec(pathsContent ?? "")) !== null) {
+      const paramsStr = match[1];
+      const params = {};
+      const paramMatches = paramsStr?.matchAll(/(\w+):\s*['"]([^'"]+)['"]/g);
+      if (paramMatches) {
+        for (const paramMatch of paramMatches) {
+          const key = paramMatch[1];
+          const value = paramMatch[2];
+          if (key !== void 0 && value !== void 0) {
+            params[key] = value;
+          }
+        }
+      }
+      paths.push({ params });
+    }
+    if (!Array.isArray(paths)) {
+      throw new Error(`Invalid getStaticPaths format in ${pathsFile}: must return { paths: [] }`);
+    }
+    return { paths };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Invalid getStaticPaths")) {
+      throw error;
+    }
+    throw new Error(`Invalid getStaticPaths format in ${pathsFile}`);
+  }
+}
+async function loadLayout2(layoutName, layoutsDir) {
+  const layoutPath = join9(layoutsDir, `${layoutName}.json`);
+  if (!existsSync7(layoutPath)) {
+    throw new Error(`Layout "${layoutName}" not found at ${layoutPath}`);
+  }
+  try {
+    const content = readFileSync5(layoutPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    throw new Error(`Invalid JSON in layout file: ${layoutPath}`);
+  }
+}
+function applyLayout(pageView, layoutView) {
+  return replaceSlot(layoutView, pageView);
+}
+function normalizeProps(props) {
+  if (!props || typeof props !== "object") {
+    return {};
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (value && typeof value === "object" && "expr" in value) {
+      normalized[key] = value;
+    } else if (value !== void 0 && value !== null) {
+      normalized[key] = { expr: "lit", value };
+    }
+  }
+  return normalized;
+}
+function normalizeExpression(expr) {
+  if (!expr || typeof expr !== "object") {
+    return expr;
+  }
+  const exprObj = expr;
+  if (exprObj["expr"] === "param" && typeof exprObj["name"] === "string") {
+    return {
+      expr: "route",
+      source: "param",
+      name: exprObj["name"]
+    };
+  }
+  return expr;
+}
+function normalizeViewNode(node) {
+  if (!node || typeof node !== "object") {
+    return node;
+  }
+  const nodeObj = node;
+  if (nodeObj["props"]) {
+    nodeObj["props"] = normalizeProps(nodeObj["props"]);
+  }
+  if (nodeObj["kind"] === "text" && nodeObj["value"]) {
+    nodeObj["value"] = normalizeExpression(nodeObj["value"]);
+  }
+  if (Array.isArray(nodeObj["children"])) {
+    nodeObj["children"] = nodeObj["children"].map((child) => normalizeViewNode(child));
+  }
+  return nodeObj;
+}
+function replaceSlot(node, content) {
+  if (!node || typeof node !== "object") {
+    return node;
+  }
+  const nodeObj = node;
+  if (nodeObj["kind"] === "slot") {
+    return content;
+  }
+  if (Array.isArray(nodeObj["children"])) {
+    return {
+      ...nodeObj,
+      children: nodeObj["children"].map((child) => replaceSlot(child, content))
+    };
+  }
+  return node;
+}
+async function processLayouts(pageInfo, layoutsDir) {
+  const layoutName = pageInfo.page.route?.layout;
+  if (!layoutName || !layoutsDir) {
+    return pageInfo;
+  }
+  const layout = await loadLayout2(layoutName, layoutsDir);
+  const normalizedLayoutView = normalizeViewNode(structuredClone(layout.view));
+  const wrappedView = applyLayout(pageInfo.page.view, normalizedLayoutView);
+  let updatedRoute;
+  if (pageInfo.page.route) {
+    const { layout: _layout, ...routeWithoutLayout } = pageInfo.page.route;
+    updatedRoute = routeWithoutLayout;
+  }
+  let updatedPageInfo = {
+    ...pageInfo,
+    page: {
+      ...pageInfo.page,
+      view: wrappedView,
+      route: updatedRoute
+    }
+  };
+  if (layout.layout) {
+    const parentLayout = await loadLayout2(layout.layout, layoutsDir);
+    const normalizedParentLayoutView = normalizeViewNode(structuredClone(parentLayout.view));
+    const doubleWrappedView = applyLayout(updatedPageInfo.page.view, normalizedParentLayoutView);
+    updatedPageInfo = {
+      ...updatedPageInfo,
+      page: {
+        ...updatedPageInfo.page,
+        view: doubleWrappedView
+      }
+    };
+  }
+  return updatedPageInfo;
+}
+async function renderPageToHtml(program, params, runtimePath) {
+  const normalizedProgram = {
+    ...program,
+    view: normalizeViewNode(structuredClone(program.view))
+  };
+  const ctx = {
+    url: "/",
+    params,
+    query: new URLSearchParams()
+  };
+  const content = await renderPage(normalizedProgram, ctx);
+  const routeContext = {
+    params,
+    query: {},
+    path: "/"
+  };
+  const hydrationScript = generateHydrationScript(normalizedProgram, void 0, routeContext);
+  return wrapHtml(content, hydrationScript, void 0, runtimePath ? { runtimePath } : void 0);
+}
+async function copyPublicDir(publicDir, outDir, generatedFiles) {
+  if (!existsSync7(publicDir)) {
+    return;
+  }
+  await copyDirRecursive(publicDir, outDir, generatedFiles);
+}
+async function copyDirRecursive(srcDir, destDir, skipFiles) {
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join9(srcDir, entry.name);
+    const destPath = join9(destDir, entry.name);
+    if (entry.isDirectory()) {
+      await mkdir2(destPath, { recursive: true });
+      await copyDirRecursive(srcPath, destPath, skipFiles);
+    } else {
+      if (skipFiles.has(destPath)) {
+        continue;
+      }
+      await mkdir2(dirname5(destPath), { recursive: true });
+      await cp(srcPath, destPath);
+    }
+  }
+}
+function validateJsonPage(content, filePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error(`Invalid JSON in ${filePath}`);
+  }
+  const page = parsed;
+  if (!page["view"]) {
+    throw new Error(`Missing required field "view" in ${filePath}`);
+  }
+  return page;
+}
+async function build2(options) {
+  const outDir = options?.outDir ?? "dist";
+  const routesDir = options?.routesDir ?? "src/routes";
+  const publicDir = options?.publicDir;
+  const layoutsDir = options?.layoutsDir;
+  const generatedFiles = [];
+  await mkdir2(outDir, { recursive: true });
+  let scannedRoutes = [];
+  try {
+    scannedRoutes = await scanRoutes(routesDir);
+  } catch {
+    return {
+      outDir,
+      routes: [],
+      generatedFiles: []
+    };
+  }
+  const routes = scannedRoutes.map((r) => r.pattern);
+  const jsonPages = scannedRoutes.filter(
+    (route) => route.type === "page" && route.file.endsWith(".json")
+  );
+  if (jsonPages.length === 0) {
+    if (publicDir) {
+      const generatedSet = new Set(generatedFiles);
+      await copyPublicDir(publicDir, outDir, generatedSet);
+    }
+    return {
+      outDir,
+      routes,
+      generatedFiles: []
+    };
+  }
+  const runtimePath = await bundleRuntime({ outDir });
+  for (const route of jsonPages) {
+    const relPath = relative2(routesDir, route.file);
+    const content = readFileSync5(route.file, "utf-8");
+    const page = validateJsonPage(content, route.file);
+    if (isDynamicRoute(route.pattern)) {
+      const staticPaths = await loadGetStaticPaths(route.file);
+      if (!staticPaths) {
+        continue;
+      }
+      if (!staticPaths.paths || !Array.isArray(staticPaths.paths)) {
+        throw new Error(`Invalid getStaticPaths format in ${route.file}`);
+      }
+      for (const pathEntry of staticPaths.paths) {
+        const params = pathEntry.params;
+        const outputPath = paramsToOutputPath(route.pattern, params, outDir);
+        const loader = new JsonPageLoader(routesDir);
+        let pageInfo = await loader.loadPage(relPath);
+        if (layoutsDir) {
+          pageInfo = await processLayouts(pageInfo, layoutsDir);
+        }
+        const program = await convertToCompiledProgram(pageInfo);
+        const html = await renderPageToHtml(program, params, runtimePath);
+        await mkdir2(dirname5(outputPath), { recursive: true });
+        await writeFile(outputPath, html, "utf-8");
+        generatedFiles.push(outputPath);
+        let routePath = route.pattern;
+        for (const [key, value] of Object.entries(params)) {
+          routePath = routePath.replace(`:${key}`, value);
+          routePath = routePath.replace("*", value);
+        }
+        routes.push(routePath);
+      }
+    } else {
+      const outputPath = getOutputPath(relPath, outDir);
+      const loader = new JsonPageLoader(routesDir);
+      let pageInfo = await loader.loadPage(relPath);
+      if (layoutsDir) {
+        pageInfo = await processLayouts(pageInfo, layoutsDir);
+      }
+      const program = await convertToCompiledProgram(pageInfo);
+      const html = await renderPageToHtml(program, {}, runtimePath);
+      await mkdir2(dirname5(outputPath), { recursive: true });
+      await writeFile(outputPath, html, "utf-8");
+      generatedFiles.push(outputPath);
+    }
+  }
+  if (publicDir) {
+    const generatedSet = new Set(generatedFiles);
+    await copyPublicDir(publicDir, outDir, generatedSet);
+  }
+  return {
+    outDir,
+    routes,
+    generatedFiles
+  };
+}
+
+export {
+  filePathToPattern,
+  scanRoutes,
+  isPathSafe,
+  getMimeType,
+  resolveStaticFile,
+  mdxToConstela,
+  mdxContentToNode2 as mdxContentToNode,
+  loadComponentDefinitions,
+  transformMdx,
+  transformYaml,
+  transformCsv,
+  loadGlob,
+  loadFile,
+  loadApi,
+  generateStaticPaths,
+  DataLoader,
+  scanLayouts,
+  resolveLayout,
+  loadLayout,
+  LayoutResolver,
+  createDevServer,
+  build2 as build
+};