@squadbase/vantage 0.0.1

package/dist/chunk-ZGDU5YLH.js

@@ -0,0 +1,753 @@
+import { matchApiRoute, dispatchApi, sortApiRoutes } from './chunk-73J5ZD4C.js';
+import fs2 from 'fs';
+import path3 from 'path';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+import pc from 'picocolors';
+import { createRequire } from 'module';
+import { Hono } from 'hono';
+import { getRequestListener } from '@hono/node-server';
+
+// @squadbase/vantage — generated build. Do not edit.
+
+// src/core/constants.ts
+var VANTAGE_DIR = ".vantage";
+var NON_ROUTE_DIRS = /* @__PURE__ */ new Set([
+  "components",
+  "hooks",
+  "lib",
+  "server",
+  "public",
+  "node_modules",
+  VANTAGE_DIR,
+  "dist"
+]);
+var PAGE_EXTENSIONS = [".tsx", ".jsx"];
+var API_EXTENSIONS = [".ts", ".tsx", ".js"];
+var RESERVED_PAGE_NAMES = {
+  layout: "_layout",
+  notFound: "_404",
+  error: "_error"
+};
+var API_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+var FORBIDDEN_FILES = [
+  {
+    pattern: /^vite\.config\.(ts|js|mjs|cjs|mts|cts)$/,
+    label: "Vite config",
+    remedy: "Vantage owns the Vite configuration. Remove this file."
+  },
+  {
+    pattern: /^tailwind\.config\.(ts|js|mjs|cjs)$/,
+    label: "Tailwind config",
+    remedy: "Customize theme tokens in styles.css instead."
+  },
+  {
+    pattern: /^postcss\.config\.(ts|js|mjs|cjs)$/,
+    label: "PostCSS config",
+    remedy: "Vantage manages PostCSS/Tailwind. Remove this file."
+  },
+  {
+    pattern: /^components\.json$/,
+    label: "shadcn components.json",
+    remedy: "Use `vantage add ui <name>` to copy UI source instead."
+  },
+  {
+    pattern: /^vantage\.config\.(ts|js|mjs|cjs)$/,
+    label: "Vantage config",
+    remedy: "v1 has no vantage.config. Configuration lives in file conventions."
+  }
+];
+var PUBLIC_ENV_PREFIX = "PUBLIC_";
+var MANIFEST_SCHEMA_VERSION = 1;
+function segToRouter(s) {
+  if (s.kind === "static") return s.value;
+  if (s.kind === "param") return `$${s.name}`;
+  return "$";
+}
+function dirToRouterPath(relDir) {
+  return relDir.split("/").filter(Boolean).map((token) => {
+    const catchall = token.match(/^\[\.\.\.(.+)\]$/);
+    if (catchall) return "$";
+    const param = token.match(/^\[(.+)\]$/);
+    if (param) return `$${param[1]}`;
+    return token;
+  }).join("/");
+}
+function isAncestorDir(ancestor, dir) {
+  if (ancestor === "") return true;
+  return dir === ancestor || dir.startsWith(ancestor + "/");
+}
+function isStrictAncestorDir(ancestor, dir) {
+  return dir.startsWith(ancestor + "/");
+}
+function depth(dir) {
+  return dir === "" ? 0 : dir.split("/").length;
+}
+function extractDefinePageArgs(src) {
+  const call = src.match(/\bdefinePage\s*\(/);
+  if (!call) return null;
+  let i = (call.index ?? 0) + call[0].length;
+  while (i < src.length && /\s/.test(src[i])) i++;
+  if (src[i] !== "{") return null;
+  const start = i;
+  let depth2 = 0;
+  for (; i < src.length; i++) {
+    const c = src[i];
+    if (c === "{") depth2++;
+    else if (c === "}" && --depth2 === 0) return src.slice(start + 1, i);
+  }
+  return null;
+}
+function matchStringField(scope, key) {
+  const re = new RegExp(
+    `\\b${key}\\s*:\\s*(?:"((?:\\\\.|[^"\\\\])*)"|'((?:\\\\.|[^'\\\\])*)'|\`((?:\\\\.|[^\`\\\\])*)\`)`
+  );
+  const m = scope.match(re);
+  if (!m) return void 0;
+  return (m[1] ?? m[2] ?? m[3] ?? "").replace(/\\(.)/g, "$1");
+}
+function extractPageMeta(absFile) {
+  let src;
+  try {
+    src = fs2.readFileSync(absFile, "utf8");
+  } catch {
+    return {};
+  }
+  const args = extractDefinePageArgs(src);
+  if (args == null) return {};
+  const meta = {};
+  const title = matchStringField(args, "title");
+  const description = matchStringField(args, "description");
+  if (title) meta.title = title;
+  if (description) meta.description = description;
+  return meta;
+}
+function buildRouteTree(model) {
+  const rootLayoutRoute = model.layouts.find((l) => l.dir === "") ?? null;
+  const nestedLayouts = model.layouts.filter((l) => l.dir !== "").sort((a, b) => depth(a.dir) - depth(b.dir));
+  const built = [];
+  const dirToId = /* @__PURE__ */ new Map();
+  nestedLayouts.forEach((layout, i) => {
+    const id = `L${i}`;
+    let parent = null;
+    for (const cand of built) {
+      if (isStrictAncestorDir(cand.dir, layout.dir)) {
+        if (!parent || depth(cand.dir) > depth(parent.dir)) parent = { id: cand.id, dir: cand.dir };
+      }
+    }
+    const parentDir = parent ? parent.dir : "";
+    const relDir = parentDir === "" ? layout.dir : layout.dir.slice(parentDir.length + 1);
+    built.push({
+      id,
+      dir: layout.dir,
+      parentId: parent ? parent.id : null,
+      path: dirToRouterPath(relDir),
+      file: layout.file
+    });
+    dirToId.set(layout.dir, id);
+  });
+  const pages = model.pages.map((page) => {
+    let owner = null;
+    for (const l of built) {
+      if (isAncestorDir(l.dir, page.dir)) {
+        if (!owner || depth(l.dir) > depth(owner.dir)) owner = l;
+      }
+    }
+    const ownerSegCount = owner ? depth(owner.dir) : 0;
+    const remaining = page.segments.slice(ownerSegCount);
+    const index = remaining.length === 0;
+    const path4 = index ? "/" : remaining.map(segToRouter).join("/");
+    const meta = extractPageMeta(page.absFile);
+    return {
+      file: page.file,
+      routePath: page.routePath,
+      parentLayoutId: owner ? owner.id : null,
+      path: path4,
+      index,
+      ...meta.title ? { title: meta.title } : {},
+      ...meta.description ? { description: meta.description } : {}
+    };
+  });
+  return {
+    rootLayout: rootLayoutRoute ? rootLayoutRoute.file : null,
+    notFound: model.notFound,
+    error: model.error,
+    layouts: built,
+    pages
+  };
+}
+
+// src/core/generate.ts
+var PKG = "@squadbase/vantage";
+function resolveVantageDir(root) {
+  try {
+    const require2 = createRequire(path3.join(root, "noop.js"));
+    const pkgJson = require2.resolve(`${PKG}/package.json`);
+    return path3.dirname(pkgJson);
+  } catch {
+    return null;
+  }
+}
+function importFromVantage(relFile) {
+  return `../${relFile}`;
+}
+function ensureDir(dir) {
+  fs2.mkdirSync(dir, { recursive: true });
+}
+function writeIfChanged(file, content) {
+  try {
+    if (fs2.existsSync(file) && fs2.readFileSync(file, "utf8") === content) return;
+  } catch {
+  }
+  fs2.writeFileSync(file, content);
+}
+function serializeSegments(segments) {
+  return "[" + segments.map((s) => {
+    if (s.kind === "static") return `{ kind: "static", value: ${JSON.stringify(s.value)} }`;
+    if (s.kind === "param") return `{ kind: "param", name: ${JSON.stringify(s.name)} }`;
+    return `{ kind: "catchall", name: ${JSON.stringify(s.name)} }`;
+  }).join(", ") + "]";
+}
+var BANNER = "// AUTO-GENERATED by @squadbase/vantage. Do not edit \u2014 regenerated on every run.\n";
+function renderRouteTree(model) {
+  const tree = buildRouteTree(model);
+  const lines = [];
+  lines.push(BANNER);
+  lines.push(`import type { ClientManifest } from "${PKG}/client"`);
+  lines.push("");
+  lines.push("export const manifest: ClientManifest = {");
+  lines.push(
+    `  rootLayout: ${tree.rootLayout ? `() => import(${JSON.stringify(importFromVantage(tree.rootLayout))})` : "null"},`
+  );
+  lines.push(
+    `  notFound: ${tree.notFound ? `() => import(${JSON.stringify(importFromVantage(tree.notFound))})` : "null"},`
+  );
+  lines.push(
+    `  error: ${tree.error ? `() => import(${JSON.stringify(importFromVantage(tree.error))})` : "null"},`
+  );
+  lines.push("  layouts: [");
+  for (const l of tree.layouts) {
+    lines.push(
+      `    { id: ${JSON.stringify(l.id)}, parentId: ${JSON.stringify(l.parentId)}, path: ${JSON.stringify(
+        l.path
+      )}, load: () => import(${JSON.stringify(importFromVantage(l.file))}) },`
+    );
+  }
+  lines.push("  ],");
+  lines.push("  pages: [");
+  for (const p of tree.pages) {
+    const extra = [];
+    if (p.title) extra.push(`title: ${JSON.stringify(p.title)}`);
+    if (p.description) extra.push(`description: ${JSON.stringify(p.description)}`);
+    lines.push(
+      `    { parentLayoutId: ${JSON.stringify(p.parentLayoutId)}, path: ${JSON.stringify(
+        p.path
+      )}, index: ${p.index}, routePath: ${JSON.stringify(p.routePath)}${extra.length ? ", " + extra.join(", ") : ""}, load: () => import(${JSON.stringify(importFromVantage(p.file))}) },`
+    );
+  }
+  lines.push("  ],");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function renderServerRoutes(model) {
+  const lines = [];
+  lines.push(BANNER);
+  lines.push(`import type { ProdApiRoute } from "${PKG}/server/node"`);
+  model.apis.forEach((a, i) => {
+    lines.push(`import * as m${i} from ${JSON.stringify(importFromVantage(a.file))}`);
+  });
+  lines.push("");
+  lines.push("export const apiRoutes: ProdApiRoute[] = [");
+  model.apis.forEach((a, i) => {
+    lines.push(
+      `  { routePath: ${JSON.stringify(a.routePath)}, segments: ${serializeSegments(
+        a.segments
+      )}, module: m${i} },`
+    );
+  });
+  lines.push("]");
+  lines.push("");
+  return lines.join("\n");
+}
+function renderIndexHtml() {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vantage</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/.vantage/client-entry.tsx"></script>
+  </body>
+</html>
+`;
+}
+function renderClientEntry() {
+  return `${BANNER}import { bootstrap } from "${PKG}/client"
+import { manifest } from "./route-tree.gen"
+import "./runtime.css"
+
+bootstrap(manifest)
+`;
+}
+function renderRuntimeCss(root) {
+  const parts = [];
+  parts.push('@import "tailwindcss";');
+  parts.push(`@import "${PKG}/theme.css";`);
+  if (fs2.existsSync(path3.join(root, "styles.css"))) {
+    parts.push('@import "../styles.css";');
+  }
+  const vantageDir = resolveVantageDir(root);
+  if (vantageDir) {
+    const uiDir = path3.join(vantageDir, "dist", "ui");
+    parts.push(`@source ${JSON.stringify(uiDir)};`);
+  }
+  return parts.join("\n") + "\n";
+}
+function renderEnvTypes() {
+  return `${BANNER}
+interface ImportMetaEnv {
+  readonly MODE: string
+  readonly DEV: boolean
+  readonly PROD: boolean
+  readonly SSR: boolean
+  readonly BASE_URL: string
+  readonly [key: \`PUBLIC_\${string}\`]: string | undefined
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
+
+declare module "*.css" {
+  const content: string
+  export default content
+}
+`;
+}
+function renderInternalManifest(model) {
+  return JSON.stringify(
+    {
+      schemaVersion: MANIFEST_SCHEMA_VERSION,
+      pages: model.pages.map((p) => ({ file: p.file, route: p.routePath })),
+      apis: model.apis.map((a) => ({ file: a.file, route: a.routePath })),
+      hasServer: model.hasServer
+    },
+    null,
+    2
+  ) + "\n";
+}
+function generateArtifacts({ root, model }) {
+  const vantageDir = path3.join(root, VANTAGE_DIR);
+  ensureDir(vantageDir);
+  ensureDir(path3.join(vantageDir, "types"));
+  writeIfChanged(path3.join(vantageDir, ".gitignore"), "*\n");
+  writeIfChanged(path3.join(vantageDir, "index.html"), renderIndexHtml());
+  writeIfChanged(path3.join(vantageDir, "client-entry.tsx"), renderClientEntry());
+  writeIfChanged(path3.join(vantageDir, "route-tree.gen.ts"), renderRouteTree(model));
+  writeIfChanged(path3.join(vantageDir, "runtime.css"), renderRuntimeCss(root));
+  writeIfChanged(path3.join(vantageDir, "types", "env.d.ts"), renderEnvTypes());
+  writeIfChanged(path3.join(vantageDir, "manifest.json"), renderInternalManifest(model));
+  if (model.hasServer) {
+    writeIfChanged(path3.join(vantageDir, "server-routes.gen.ts"), renderServerRoutes(model));
+  }
+  return vantageDir;
+}
+function toPosix(root, abs) {
+  return path3.relative(root, abs).split(path3.sep).join("/");
+}
+function parseRawSegment(raw) {
+  const catchall = raw.match(/^\[\.\.\.(.+)\]$/);
+  if (catchall) return { kind: "catchall", name: catchall[1] };
+  const param = raw.match(/^\[(.+)\]$/);
+  if (param) return { kind: "param", name: param[1] };
+  return { kind: "static", value: raw };
+}
+function displayPath(segments) {
+  if (segments.length === 0) return "/";
+  const parts = segments.map((s) => {
+    if (s.kind === "static") return s.value;
+    if (s.kind === "param") return `:${s.name}`;
+    return "*";
+  });
+  return "/" + parts.join("/");
+}
+function fileToSegments(relNoExt) {
+  const raw = relNoExt.split("/");
+  if (raw[raw.length - 1] === "index") raw.pop();
+  return raw.map(parseRawSegment);
+}
+function stripExt(file, exts) {
+  for (const ext of exts) {
+    if (file.endsWith(ext)) return file.slice(0, -ext.length);
+  }
+  return file;
+}
+function hasExt(file, exts) {
+  return exts.some((ext) => file.endsWith(ext));
+}
+function walk(dir, root, out) {
+  let entries;
+  try {
+    entries = fs2.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const abs = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (NON_ROUTE_DIRS.has(entry.name)) continue;
+      if (entry.name.startsWith(".")) continue;
+      walk(abs, root, out);
+    } else if (entry.isFile()) {
+      out.push(abs);
+    }
+  }
+}
+function scanPages(root) {
+  const files = [];
+  walk(root, root, files);
+  const pages = [];
+  const layouts = [];
+  let notFound = null;
+  let error = null;
+  for (const abs of files) {
+    const rel = toPosix(root, abs);
+    const base = path3.posix.basename(rel);
+    if (!hasExt(base, PAGE_EXTENSIONS)) continue;
+    const nameNoExt = stripExt(base, PAGE_EXTENSIONS);
+    const dir = path3.posix.dirname(rel);
+    const dirPosix = dir === "." ? "" : dir;
+    if (nameNoExt === RESERVED_PAGE_NAMES.layout) {
+      layouts.push({ file: rel, absFile: abs, dir: dirPosix });
+      continue;
+    }
+    if (nameNoExt === RESERVED_PAGE_NAMES.notFound) {
+      if (dirPosix === "") notFound = rel;
+      continue;
+    }
+    if (nameNoExt === RESERVED_PAGE_NAMES.error) {
+      if (dirPosix === "") error = rel;
+      continue;
+    }
+    if (nameNoExt.startsWith("_")) continue;
+    const relNoExt = stripExt(rel, PAGE_EXTENSIONS);
+    const segments = fileToSegments(relNoExt);
+    const routePath = displayPath(segments);
+    const dynamic = segments.some((s) => s.kind !== "static");
+    pages.push({ file: rel, absFile: abs, routePath, segments, dir: dirPosix, dynamic });
+  }
+  pages.sort((a, b) => routeSortKey(a).localeCompare(routeSortKey(b)));
+  layouts.sort((a, b) => a.dir.localeCompare(b.dir));
+  return { pages, layouts, notFound, error };
+}
+function routeSortKey(p) {
+  return p.segments.map((s) => s.kind === "static" ? "0" + s.value : s.kind === "param" ? "1" : "2").join("/");
+}
+function scanApis(root) {
+  const apiDir = path3.join(root, "server", "api");
+  if (!fs2.existsSync(apiDir)) return [];
+  const files = [];
+  const walkApi = (dir) => {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = path3.join(dir, entry.name);
+      if (entry.isDirectory()) walkApi(abs);
+      else if (entry.isFile()) files.push(abs);
+    }
+  };
+  walkApi(apiDir);
+  const apis = [];
+  for (const abs of files) {
+    const base = path3.basename(abs);
+    if (!hasExt(base, API_EXTENSIONS)) continue;
+    const nameNoExt = stripExt(base, API_EXTENSIONS);
+    if (base.endsWith(".d.ts")) continue;
+    if (nameNoExt.startsWith("_")) continue;
+    const relFromServer = toPosix(path3.join(root, "server"), abs);
+    const relNoExt = stripExt(relFromServer, API_EXTENSIONS);
+    const withoutApiPrefix = relNoExt.replace(/^api\/?/, "");
+    const segTokens = withoutApiPrefix === "" ? [] : withoutApiPrefix.split("/");
+    if (segTokens[segTokens.length - 1] === "index") segTokens.pop();
+    const segments = segTokens.map(parseRawSegment);
+    const routePath = "/api" + (segments.length ? displayPath(segments) : "");
+    const params = segments.filter((s) => s.kind !== "static").map((s) => s.name);
+    apis.push({
+      file: toPosix(root, abs),
+      absFile: abs,
+      routePath,
+      pattern: routePath,
+      segments,
+      params
+    });
+  }
+  apis.sort((a, b) => a.routePath.localeCompare(b.routePath));
+  return apis;
+}
+function scanProject(root) {
+  const { pages, layouts, notFound, error } = scanPages(root);
+  const hasServer = fs2.existsSync(path3.join(root, "server"));
+  const apis = hasServer ? scanApis(root) : [];
+  return { pages, layouts, notFound, error, apis, hasServer };
+}
+function createApiDevMiddleware(opts) {
+  const { server, getModel, getEnv } = opts;
+  const buildRoutes = () => sortApiRoutes(
+    getModel().apis.map((a) => ({
+      routePath: a.routePath,
+      segments: a.segments,
+      hasCatchall: a.segments.some((s) => s.kind === "catchall"),
+      staticCount: a.segments.filter((s) => s.kind === "static").length,
+      load: () => server.ssrLoadModule(a.absFile)
+    }))
+  );
+  const app = new Hono();
+  const handle = async (c) => {
+    const url = new URL(c.req.url);
+    const match = matchApiRoute(buildRoutes(), url.pathname);
+    if (!match) {
+      return Response.json({ error: "Not Found", path: url.pathname }, { status: 404 });
+    }
+    let mod;
+    try {
+      mod = await match.route.load();
+    } catch (err) {
+      if (err instanceof Error) server.ssrFixStacktrace(err);
+      throw err;
+    }
+    return dispatchApi(mod, c.req.raw, match.params, getEnv());
+  };
+  app.all("/api", handle);
+  app.all("/api/*", handle);
+  const listener = getRequestListener(app.fetch);
+  return (req, res, next) => {
+    const url = req.url ?? "/";
+    const path4 = url.split("?")[0];
+    if (path4 === "/api" || path4.startsWith("/api/")) {
+      Promise.resolve(listener(req, res)).catch((err) => {
+        console.error("[vantage] API middleware failure:", err);
+        if (!res.headersSent) {
+          res.statusCode = 500;
+          res.setHeader("content-type", "application/json");
+          res.end(JSON.stringify({ error: "Internal Server Error" }));
+        }
+      });
+    } else {
+      next();
+    }
+  };
+}
+
+// src/vite/index.ts
+var DEDUPE = ["react", "react-dom", "@tanstack/react-router", "@tanstack/react-query"];
+function isPageFile(root, file) {
+  const rel = path3.relative(root, file);
+  if (rel.startsWith("..")) return false;
+  const segments = rel.split(path3.sep);
+  if (segments.some((s) => NON_ROUTE_DIRS.has(s) || s.startsWith(".") && s !== "..")) return false;
+  return PAGE_EXTENSIONS.some((ext) => file.endsWith(ext));
+}
+function isApiFile(root, file) {
+  const rel = path3.relative(root, file);
+  return rel.startsWith(`server${path3.sep}api${path3.sep}`) && /\.(ts|tsx|js)$/.test(file) && !file.endsWith(".d.ts");
+}
+function isServerFile(root, file) {
+  const rel = path3.relative(root, file);
+  return rel === "server" || rel.startsWith(`server${path3.sep}`);
+}
+function vantagePlugin(options) {
+  const root = path3.resolve(options.root);
+  const vantageDir = path3.join(root, VANTAGE_DIR);
+  let model = scanProject(root);
+  const regenerate = () => {
+    model = scanProject(root);
+    generateArtifacts({ root, model });
+  };
+  const core = {
+    name: "vantage:core",
+    enforce: "pre",
+    config() {
+      return {
+        root,
+        appType: "custom",
+        envPrefix: ["PUBLIC_"],
+        resolve: { dedupe: DEDUPE },
+        optimizeDeps: {
+          // Only list deps resolvable from the project root here; the managed
+          // @tanstack/* packages are discovered through the module graph.
+          include: ["react", "react-dom", "react-dom/client", "react/jsx-runtime"]
+        },
+        build: {
+          outDir: path3.join(root, "dist", "client"),
+          emptyOutDir: true,
+          rollupOptions: {
+            input: path3.join(vantageDir, "index.html")
+          }
+        }
+      };
+    },
+    configResolved() {
+      regenerate();
+    },
+    buildStart() {
+      regenerate();
+    },
+    // --- Server-import boundary: client code may never import server/. ---
+    resolveId(source, importer, opts) {
+      if (opts?.ssr) return null;
+      if (!importer) return null;
+      const imp = importer.split("?")[0];
+      if (!imp.startsWith(root)) return null;
+      const relImp = path3.relative(root, imp);
+      if (relImp.startsWith(`server${path3.sep}`) || relImp.startsWith(VANTAGE_DIR) || relImp.includes("node_modules")) {
+        return null;
+      }
+      let target = null;
+      if (source.startsWith(".")) target = path3.resolve(path3.dirname(imp), source);
+      else if (source.startsWith("/")) target = path3.join(root, source.slice(1));
+      else if (source === "server" || source.startsWith("server/")) target = path3.join(root, source);
+      if (!target) return null;
+      const relTarget = path3.relative(root, target);
+      if (relTarget === "server" || relTarget.startsWith(`server${path3.sep}`)) {
+        this.error(
+          `Client module "${relImp}" imports from server/ ("${source}"). server/ code must never reach the client bundle \u2014 move shared code to lib/.`
+        );
+      }
+      return null;
+    },
+    // --- Keep React Fast Refresh working on page modules. ---
+    // `export const page = definePage(...)` is a non-component export, which
+    // makes @vitejs/plugin-react bail out of Fast Refresh (full reload). The
+    // runtime never reads this export (title/description are extracted at
+    // generate time), so we drop the `export` keyword — turning it into a local
+    // const — before the React plugin analyzes the module. Offsets are
+    // preserved (6 spaces for "export") so sourcemaps stay accurate.
+    transform(code, id) {
+      const clean = id.split("?")[0];
+      if (!isPageFile(root, clean)) return null;
+      if (!/export\s+const\s+page\b/.test(code)) return null;
+      const out = code.replace(
+        /^([ \t]*)export(\s+const\s+page\b)/gm,
+        (_m, indent, rest) => indent + "      " + rest
+      );
+      if (out === code) return null;
+      return { code: out, map: null };
+    },
+    // --- Dev console + runtime errors forwarded to the terminal. ---
+    transformIndexHtml: {
+      order: "pre",
+      handler(_html, ctx) {
+        if (!ctx.server) return [];
+        return [
+          {
+            tag: "script",
+            attrs: { type: "module" },
+            injectTo: "head-prepend",
+            children: CONSOLE_BRIDGE
+          }
+        ];
+      }
+    },
+    configureServer(server) {
+      const getEnv = () => options.env ?? process.env;
+      const apiMw = createApiDevMiddleware({ server, getModel: () => model, getEnv });
+      server.middlewares.use((req, res, next) => {
+        const url = (req.url ?? "/").split("?")[0];
+        if (url === "/__vantage_console" && req.method === "POST") {
+          return handleConsoleBeacon(req, res);
+        }
+        if (model.hasServer) return apiMw(req, res, next);
+        return next();
+      });
+      const isStylesFile = (file) => path3.relative(root, file) === "styles.css";
+      const onStructural = (file) => {
+        if (isPageFile(root, file) || isApiFile(root, file) || isStylesFile(file)) {
+          regenerate();
+          server.ws.send({ type: "full-reload" });
+        }
+      };
+      server.watcher.on("add", onStructural);
+      server.watcher.on("unlink", onStructural);
+      server.watcher.on("addDir", () => {
+        regenerate();
+      });
+      server.watcher.on("unlinkDir", () => {
+        regenerate();
+        server.ws.send({ type: "full-reload" });
+      });
+      server.watcher.on("change", (file) => {
+        if (isServerFile(root, file)) {
+          const mods = server.moduleGraph.getModulesByFile(file);
+          if (mods) for (const m of mods) server.moduleGraph.invalidateModule(m);
+        }
+      });
+      return () => {
+        server.middlewares.use(async (req, res, next) => {
+          if (req.method !== "GET" && req.method !== "HEAD") return next();
+          try {
+            const raw = fs2.readFileSync(path3.join(vantageDir, "index.html"), "utf8");
+            const html = await server.transformIndexHtml(req.url ?? "/", raw, req.originalUrl);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "text/html");
+            res.end(html);
+          } catch (err) {
+            next(err);
+          }
+        });
+      };
+    }
+  };
+  return [core, react(), tailwindcss()];
+}
+var CONSOLE_BRIDGE = `
+(() => {
+  const send = (level, message) => {
+    try {
+      const body = JSON.stringify({ level, message });
+      if (navigator.sendBeacon) navigator.sendBeacon("/__vantage_console", body);
+      else fetch("/__vantage_console", { method: "POST", body, keepalive: true });
+    } catch (_) {}
+  };
+  const fmt = (args) => args.map((a) => {
+    if (a instanceof Error) return a.stack || a.message;
+    if (typeof a === "object") { try { return JSON.stringify(a); } catch { return String(a); } }
+    return String(a);
+  }).join(" ");
+  for (const lvl of ["log", "info", "warn", "error"]) {
+    const orig = console[lvl].bind(console);
+    console[lvl] = (...args) => { send(lvl, fmt(args)); orig(...args); };
+  }
+  window.addEventListener("error", (e) => send("error", (e.message || "Error") + " @ " + (e.filename || "") + ":" + e.lineno));
+  window.addEventListener("unhandledrejection", (e) => send("error", "UnhandledRejection: " + ((e.reason && e.reason.stack) || e.reason)));
+})();
+`;
+function handleConsoleBeacon(req, res) {
+  let body = "";
+  req.on("data", (chunk) => {
+    body += chunk;
+    if (body.length > 1e6) req.destroy();
+  });
+  req.on("end", () => {
+    try {
+      const { level, message } = JSON.parse(body);
+      const tag = pc.dim(`[browser:${level}]`);
+      const color = level === "error" ? pc.red : level === "warn" ? pc.yellow : (s) => s;
+      console.log(`${tag} ${color(String(message))}`);
+    } catch {
+    }
+    res.statusCode = 204;
+    res.end();
+  });
+}
+
+export { API_METHODS, FORBIDDEN_FILES, MANIFEST_SCHEMA_VERSION, PAGE_EXTENSIONS, PUBLIC_ENV_PREFIX, VANTAGE_DIR, generateArtifacts, scanProject, vantagePlugin };
+//# sourceMappingURL=chunk-ZGDU5YLH.js.map
+//# sourceMappingURL=chunk-ZGDU5YLH.js.map