@squadbase/vantage 0.6.2-dev1.b332e5a → 0.6.2-dev1.d7c0911

package/dist/chunk-2ICNHUG6.js

@@ -0,0 +1,1820 @@
+import { generateArtifacts, setDraftArtifacts, restoreClientEntry } from './chunk-WAMZWZJB.js';
+import { scanProject, resolvePageRoot, stripExt, splitPageVariant, fileToSegments, displayPath } from './chunk-RNTDBX6S.js';
+import { corsMiddleware, matchApiRoute, dispatchApi, sortApiRoutes } from './chunk-46QI6GFC.js';
+import { VANTAGE_DIR, NON_ROUTE_DIRS, FILE_PAGE_EXTENSIONS, PAGE_EXTENSIONS, RESERVED_PAGE_NAMES } from './chunk-C2CX6GLX.js';
+import fs3 from 'fs';
+import path6 from 'path';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+import { Hono } from 'hono';
+import { getRequestListener } from '@hono/node-server';
+import { createHash, timingSafeEqual } from 'crypto';
+import { createRequire } from 'module';
+import { pathToFileURL, fileURLToPath } from 'url';
+
+// @squadbase/vantage — generated build. Do not edit.
+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 cors = corsMiddleware(getEnv());
+  if (cors) {
+    app.use("/api", cors);
+    app.use("/api/*", cors);
+  }
+  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 path7 = url.split("?")[0];
+    if (path7 === "/api" || path7.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/client/draft-skeleton-source.ts
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function draftSkeletonModuleSource(names = []) {
+  const lines = [
+    'import { createElement } from "react"',
+    'import { DraftSkeleton } from "@squadbase/vantage/client"',
+    "const Skeleton = () => createElement(DraftSkeleton)",
+    "const noop = () => undefined",
+    "export default Skeleton"
+  ];
+  for (const name of new Set(names)) {
+    if (name === "default" || !IDENTIFIER.test(name)) continue;
+    lines.push(`export const ${name} = ${/^[A-Z]/.test(name) ? "Skeleton" : "noop"}`);
+  }
+  return lines.join("\n") + "\n";
+}
+var KEEP_PER_FILE = 2;
+var BorrowedVersions = class {
+  constructor(query) {
+    this.query = query;
+  }
+  query;
+  /** Hash → content. Immutable per hash. */
+  versions = /* @__PURE__ */ new Map();
+  /** Absolute file path → the content the shown draft borrows from. */
+  sources = /* @__PURE__ */ new Map();
+  /**
+   * The content a new draft of `file` should borrow from. While the shown draft
+   * itself borrows, that is the same source again (not the shown draft, whose
+   * text changes every time and would chain wrappers); otherwise the version
+   * shown before (`shown`).
+   */
+  sourceFor(file, shown) {
+    return this.sources.get(file) ?? shown;
+  }
+  /** Register `content` as borrowed by `file`'s next draft and return its URL. */
+  urlFor(file, url, content) {
+    const hash = createHash("sha1").update(content).digest("hex").slice(0, 12);
+    this.versions.delete(hash);
+    this.versions.set(hash, { file, content });
+    const ofFile = [...this.versions].filter(([, v]) => v.file === file);
+    for (const [h] of ofFile.slice(0, Math.max(0, ofFile.length - KEEP_PER_FILE))) this.versions.delete(h);
+    return `${url}?${this.query}=${hash}`;
+  }
+  /** Record what the draft now shown borrows from; `undefined` when it borrows nothing. */
+  shown(file, source) {
+    if (source === void 0) this.sources.delete(file);
+    else this.sources.set(file, source);
+  }
+  get(hash) {
+    return this.versions.get(hash)?.content;
+  }
+  drop(file) {
+    this.sources.delete(file);
+    for (const [h, v] of this.versions) if (v.file === file) this.versions.delete(h);
+  }
+};
+var loaded;
+async function loadTypeScript(root) {
+  try {
+    const entry = createRequire(path6.join(path6.resolve(root), "package.json")).resolve("typescript");
+    const mod = await import(pathToFileURL(entry).href);
+    const compiler = mod.default ?? mod;
+    if (typeof compiler.createSourceFile !== "function") return null;
+    loaded = compiler;
+    return loaded;
+  } catch {
+    return null;
+  }
+}
+function api() {
+  loaded ??= createRequire(import.meta.url)("typescript");
+  return loaded;
+}
+var ts = new Proxy({}, {
+  get: (_target, key) => Reflect.get(api(), key)
+});
+
+// src/vite/draft/names.ts
+function parseSource(source, fileName) {
+  const kind = /\.[jt]sx$/i.test(fileName) ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+  return ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, kind);
+}
+function bodilessFunctions(source, fileName) {
+  const found = [];
+  const hasBody = (n) => (ts.isFunctionDeclaration(n) || ts.isMethodDeclaration(n) || ts.isConstructorDeclaration(n)) && n.body !== void 0;
+  const nameOf = (n) => {
+    if (ts.isConstructorDeclaration(n)) return "constructor";
+    const name = n.name;
+    return name === void 0 ? "default" : ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : name.getText();
+  };
+  const check = (siblings) => {
+    siblings.forEach((node, i) => {
+      if (!(ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node))) return;
+      if (node.body !== void 0) return;
+      if (hasModifier(node, ts.SyntaxKind.AbstractKeyword) || inAmbientContext(node)) return;
+      const name = nameOf(node);
+      if (siblings.slice(i + 1).some((next) => hasBody(next) && nameOf(next) === name)) return;
+      found.push(name);
+    });
+  };
+  const visit = (node) => {
+    if (ts.isSourceFile(node) || ts.isBlock(node) || ts.isModuleBlock(node)) check(node.statements);
+    else if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) check(node.members);
+    ts.forEachChild(node, visit);
+  };
+  visit(parseSource(source, fileName));
+  return found;
+}
+function exportNames(source, fileName) {
+  const names = /* @__PURE__ */ new Set();
+  for (const stmt of parseSource(source, fileName).statements) {
+    if (ts.isExportAssignment(stmt)) {
+      if (!stmt.isExportEquals) names.add("default");
+    } else if (ts.isExportDeclaration(stmt)) {
+      if (stmt.isTypeOnly) continue;
+      const clause = stmt.exportClause;
+      if (clause && ts.isNamedExports(clause)) {
+        for (const spec of clause.elements) if (!spec.isTypeOnly) names.add(spec.name.text);
+      } else if (clause && ts.isNamespaceExport(clause)) {
+        names.add(clause.name.text);
+      }
+    } else if (hasModifier(stmt, ts.SyntaxKind.ExportKeyword) && !hasModifier(stmt, ts.SyntaxKind.DeclareKeyword)) {
+      if (isSignature(stmt)) continue;
+      if (hasModifier(stmt, ts.SyntaxKind.DefaultKeyword)) names.add("default");
+      else if (ts.isVariableStatement(stmt)) {
+        for (const decl of stmt.declarationList.declarations) bindingNames(decl.name, names);
+      } else if ((ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt) || ts.isEnumDeclaration(stmt)) && stmt.name) {
+        names.add(stmt.name.text);
+      }
+    }
+  }
+  return names;
+}
+function topLevelNames(source, fileName) {
+  const names = /* @__PURE__ */ new Set();
+  for (const stmt of parseSource(source, fileName).statements) {
+    if (isSignature(stmt)) continue;
+    if (ts.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) bindingNames(decl.name, names);
+    } else if ((ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt) || ts.isEnumDeclaration(stmt)) && stmt.name) {
+      names.add(stmt.name.text);
+    }
+  }
+  return names;
+}
+function boundNames(sf) {
+  const names = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (ts.isImportClause(node) && node.name) names.add(node.name.text);
+    else if (ts.isNamespaceImport(node) || ts.isImportSpecifier(node)) names.add(node.name.text);
+    else if (ts.isImportEqualsDeclaration(node)) names.add(node.name.text);
+    else if (ts.isVariableDeclaration(node) || ts.isParameter(node) || ts.isBindingElement(node))
+      bindingNames(node.name, names);
+    else if ((ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isClassDeclaration(node) || ts.isClassExpression(node) || ts.isEnumDeclaration(node)) && node.name)
+      names.add(node.name.text);
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return names;
+}
+var BROWSER_GLOBALS = /* @__PURE__ */ new Set([
+  "window",
+  "document",
+  "navigator",
+  "location",
+  "history",
+  "localStorage",
+  "sessionStorage",
+  "screen",
+  "alert",
+  "confirm",
+  "prompt",
+  "matchMedia",
+  "getComputedStyle",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "requestIdleCallback",
+  "cancelIdleCallback",
+  "ResizeObserver",
+  "IntersectionObserver",
+  "MutationObserver",
+  "Image",
+  "Audio",
+  "Node",
+  "Element",
+  "DOMParser",
+  "FileReader",
+  "File",
+  "WebSocket",
+  "Worker",
+  "Notification",
+  "indexedDB",
+  "caches",
+  "innerWidth",
+  "innerHeight",
+  "scrollTo",
+  "open",
+  "print",
+  "self",
+  "top",
+  "parent",
+  "frames",
+  "CSS",
+  "Option",
+  "customElements",
+  "DOMRect",
+  "DOMException",
+  "ClipboardItem",
+  "SpeechSynthesisUtterance",
+  "speechSynthesis",
+  "JSX",
+  "React",
+  // Window members the dev server's own `globalThis` (Node) does not have.
+  "devicePixelRatio",
+  "scrollX",
+  "scrollY",
+  "pageXOffset",
+  "pageYOffset",
+  "addEventListener",
+  "removeEventListener",
+  "dispatchEvent",
+  "postMessage",
+  "visualViewport",
+  "getSelection",
+  "XMLHttpRequest",
+  "AudioContext",
+  "Range",
+  "Text",
+  "Document",
+  "Storage",
+  "outerWidth",
+  "outerHeight",
+  "screenX",
+  "screenY",
+  "status",
+  "name",
+  "length",
+  "closed",
+  "opener",
+  "event"
+]);
+var BROWSER_GLOBAL_PATTERN = /^(HTML|SVG|CSS|DOM)\w*|Event$|Observer$/;
+var isGlobal = (name) => name === "undefined" || name === "arguments" || BROWSER_GLOBALS.has(name) || BROWSER_GLOBAL_PATTERN.test(name) || name in globalThis;
+function undeclaredNames(source, fileName) {
+  const sf = parseSource(source, fileName);
+  const bound = boundNames(sf);
+  const missing = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (ts.isTypeNode(node) && !ts.isExpressionWithTypeArguments(node)) return;
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) return;
+    if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) return;
+    if (ts.isIdentifier(node)) {
+      const parent = node.parent;
+      const name = node.text;
+      if (!bound.has(name) && !isGlobal(name) && isValueReference(node, parent)) missing.add(name);
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return [...missing];
+}
+function isValueReference(node, parent) {
+  if (ts.isPropertyAccessExpression(parent)) return parent.expression === node;
+  if (ts.isQualifiedName(parent) || ts.isMetaProperty(parent)) return false;
+  if (ts.isTypeOfExpression(parent)) return false;
+  if (ts.isJsxAttribute(parent)) return false;
+  if (ts.isJsxOpeningElement(parent) || ts.isJsxSelfClosingElement(parent) || ts.isJsxClosingElement(parent))
+    return parent.tagName === node && /^[A-Z]/.test(node.text);
+  if (ts.isLabeledStatement(parent) || ts.isBreakStatement(parent) || ts.isContinueStatement(parent)) return false;
+  if (ts.isBindingElement(parent)) return parent.propertyName !== node && parent.name !== node;
+  if (ts.isPropertyAssignment(parent)) return parent.name !== node;
+  if (ts.isMethodDeclaration(parent) || ts.isPropertyDeclaration(parent) || ts.isGetAccessorDeclaration(parent) || ts.isSetAccessorDeclaration(parent) || ts.isPropertySignature(parent) || ts.isEnumMember(parent))
+    return parent.name !== node;
+  return true;
+}
+function bindingNames(name, into) {
+  if (ts.isIdentifier(name)) {
+    into.add(name.text);
+    return;
+  }
+  for (const el of name.elements) if (ts.isBindingElement(el)) bindingNames(el.name, into);
+}
+function inAmbientContext(node) {
+  for (let n = node; n; n = n.parent) if (hasModifier(n, ts.SyntaxKind.DeclareKeyword)) return true;
+  return false;
+}
+function isSignature(node) {
+  return ts.isFunctionDeclaration(node) && node.body === void 0;
+}
+function hasModifier(node, kind) {
+  return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((m) => m.kind === kind) ?? false);
+}
+
+// src/vite/draft/complete.ts
+function completeDraft(source, opts) {
+  const isTsx = /\.tsx$/i.test(opts.path);
+  if (!isTsx && !/\.ts$/i.test(opts.path)) return null;
+  if (/\.d\.ts$/i.test(opts.path)) return null;
+  const page = isPageModule(opts.path, opts.pageDir);
+  const needExport = page || opts.requireExport !== false;
+  if (needExport && !(page ? /\bexport\s+default\b/ : /\bexport\b/).test(source)) return null;
+  const kind = isTsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+  const snapshots = lex(source, isTsx);
+  const MAX_TRIES = 200;
+  const MAX_PARSED_CHARS = 4e6;
+  let tries = 0;
+  let parsedChars = 0;
+  for (let i = snapshots.length - 1; i >= 0 && tries < MAX_TRIES && parsedChars < MAX_PARSED_CHARS; i--) {
+    if (endsMidWord(source, snapshots[i])) continue;
+    const candidate = close(source, snapshots[i]);
+    if (candidate === null) continue;
+    tries++;
+    parsedChars += candidate.length;
+    if (parsesWithExport(candidate, opts.path, kind, page, needExport)) return candidate;
+  }
+  return null;
+}
+var CLOSERS = { paren: ")", bracket: "]", brace: "}", tplExpr: "}", jsxExpr: "}" };
+function close(source, snap) {
+  let cut = snap.pos;
+  let stack = snap.stack;
+  if (snap.openTokenStart !== null) cut = Math.min(cut, snap.openTokenStart);
+  const dropAt = stack.findIndex((f) => f.kind === "jsxTag" || f.kind === "jsxClose" || f.kind === "template");
+  if (dropAt !== -1) {
+    cut = Math.min(cut, stack[dropAt].start);
+    stack = stack.slice(0, dropAt);
+  }
+  let suffix = "";
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const f = stack[i];
+    suffix += f.kind === "jsxElem" ? `</${f.name ?? ""}>` : CLOSERS[f.kind];
+  }
+  const head = source.slice(0, cut);
+  if (!head.trim()) return null;
+  return suffix ? `${head}${needsBreak(head) ? "\n" : ""}${suffix}
+` : head;
+}
+function endsMidWord(source, snap) {
+  if (snap.pos !== source.length || snap.openTokenStart !== null) return false;
+  if (!ID_PART.test(source.charAt(source.length - 1))) return false;
+  const kind = snap.stack[snap.stack.length - 1]?.kind;
+  return kind !== "jsxElem" && kind !== "jsxTag" && kind !== "jsxClose" && kind !== "template";
+}
+function needsBreak(head) {
+  const lastLine = head.slice(head.lastIndexOf("\n") + 1);
+  return lastLine.includes("//");
+}
+function isPageModule(path7, pageDir = "") {
+  return /\.tsx$/i.test(path7) && isPagePath(path7, pageDir);
+}
+function isPagePath(path7, pageDir) {
+  let rel = path7.replace(/\\/g, "/");
+  if (pageDir !== "") {
+    if (!rel.startsWith(`${pageDir}/`)) return false;
+    rel = rel.slice(pageDir.length + 1);
+  }
+  const dirs = rel.split("/").slice(0, -1);
+  return dirs.every((d) => d !== "" && !d.startsWith(".") && !NON_ROUTE_DIRS.has(d));
+}
+function parsesWithExport(code, path7, kind, needDefault, needExport) {
+  const sf = ts.createSourceFile(path7, code, ts.ScriptTarget.Latest, false, kind);
+  const diagnostics = sf.parseDiagnostics;
+  if (diagnostics && diagnostics.length > 0) return false;
+  const exports = !needExport || sf.statements.some((s) => {
+    if (ts.isExportAssignment(s)) return true;
+    if (!needDefault && ts.isExportDeclaration(s)) return true;
+    if (!ts.canHaveModifiers(s)) return false;
+    const flags = ts.getCombinedModifierFlags(s);
+    return needDefault ? (flags & ts.ModifierFlags.ExportDefault) === ts.ModifierFlags.ExportDefault : (flags & ts.ModifierFlags.Export) !== 0;
+  });
+  return exports && bodilessFunctions(code, path7).length === 0;
+}
+var ID_START = /[A-Za-z_$]/;
+var ID_PART = /[A-Za-z0-9_$]/;
+var JSX_NAME_PART = /[A-Za-z0-9_$.:-]/;
+var EXPR_START_CHARS = /* @__PURE__ */ new Set(["", "(", ",", "=", ":", "?", "[", "{", "}", "!", "&", "|", ";", ">", "+", "-", "*", "%", "~", "^"]);
+var EXPR_START_WORDS = /* @__PURE__ */ new Set(["return", "typeof", "case", "do", "else", "in", "of", "new", "delete", "void", "throw", "yield", "await", "default"]);
+function lex(src, jsx) {
+  const stack = [];
+  const snaps = [];
+  let prev = "";
+  const top = () => stack[stack.length - 1];
+  const snap = (pos, openTokenStart = null) => snaps.push({ pos, stack: stack.slice(), openTokenStart });
+  const exprCanStart = () => EXPR_START_CHARS.has(prev) || EXPR_START_WORDS.has(prev);
+  const skipString = (i2, quote, multiline) => {
+    for (let j = i2 + 1; j < src.length; j++) {
+      const c = src[j];
+      if (c === "\\") j++;
+      else if (c === quote) return j + 1;
+      else if (c === "\n") {
+        if (!multiline) return -1;
+        snap(j, i2);
+      }
+    }
+    return -1;
+  };
+  let i = 0;
+  while (i < src.length) {
+    const c = src.charAt(i);
+    const t = top();
+    const kind = t?.kind;
+    if (c === "\n" && kind !== "template") snap(i);
+    if (kind === "template") {
+      if (c === "\n") snap(i);
+      if (c === "\\") i += 2;
+      else if (c === "`") {
+        stack.pop();
+        prev = "x";
+        i++;
+      } else if (c === "$" && src[i + 1] === "{") {
+        stack.push({ kind: "tplExpr", start: i });
+        prev = "{";
+        i += 2;
+      } else i++;
+      continue;
+    }
+    if (kind === "jsxClose") {
+      if (c === ">") {
+        stack.pop();
+        if (top()?.kind === "jsxElem") stack.pop();
+        afterJsxElement();
+      }
+      i++;
+      continue;
+    }
+    if (kind === "jsxTag") {
+      if (c === '"' || c === "'") {
+        const end = skipString(i, c, true);
+        if (end === -1) break;
+        i = end;
+      } else if (c === "{") {
+        stack.push({ kind: "jsxExpr", start: i });
+        prev = "{";
+        i++;
+      } else if (c === "/" && src[i + 1] === ">") {
+        stack.pop();
+        afterJsxElement();
+        i += 2;
+      } else if (c === ">") {
+        const tag = stack.pop();
+        stack.push({ kind: "jsxElem", start: tag.start, name: tag.name });
+        i++;
+      } else i++;
+      continue;
+    }
+    if (kind === "jsxElem") {
+      if (c === "{") {
+        stack.push({ kind: "jsxExpr", start: i });
+        prev = "{";
+        i++;
+      } else if (c === "<") {
+        i = openJsx(i);
+      } else i++;
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "/") {
+      const nl = src.indexOf("\n", i);
+      if (nl === -1) {
+        snap(src.length, i);
+        return snaps;
+      }
+      i = nl;
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "*") {
+      const endC = src.indexOf("*/", i + 2);
+      const stop = endC === -1 ? src.length : endC;
+      for (let j = src.indexOf("\n", i); j !== -1 && j < stop; j = src.indexOf("\n", j + 1)) snap(j, i);
+      if (endC === -1) {
+        snap(src.length, i);
+        return snaps;
+      }
+      i = endC + 2;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const end = skipString(i, c, false);
+      if (end === -1) {
+        const nl = src.indexOf("\n", i);
+        snap(nl === -1 ? src.length : nl, i);
+        if (nl === -1) return snaps;
+        i = nl + 1;
+        prev = "x";
+        continue;
+      }
+      i = end;
+      prev = "x";
+      continue;
+    }
+    if (c === "`") {
+      stack.push({ kind: "template", start: i });
+      i++;
+      continue;
+    }
+    if (c === "/" && exprCanStart()) {
+      let j = i + 1;
+      let inClass = false;
+      for (; j < src.length && src[j] !== "\n"; j++) {
+        if (src[j] === "\\") j++;
+        else if (src[j] === "[") inClass = true;
+        else if (src[j] === "]") inClass = false;
+        else if (src[j] === "/" && !inClass) break;
+      }
+      if (src[j] !== "/") {
+        snap(j, i);
+        if (j >= src.length) return snaps;
+        i = j;
+        continue;
+      }
+      i = j + 1;
+      while (i < src.length && ID_PART.test(src.charAt(i))) i++;
+      prev = "x";
+      continue;
+    }
+    if (c === "<" && jsx && exprCanStart() && (ID_START.test(src[i + 1] ?? "") || src[i + 1] === ">")) {
+      i = openJsx(i);
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{") {
+      stack.push({ kind: c === "(" ? "paren" : c === "[" ? "bracket" : "brace", start: i });
+      prev = c;
+      i++;
+      continue;
+    }
+    if (c === ")" || c === "]" || c === "}") {
+      if (t && (kind === "paren" || kind === "bracket" || kind === "brace" || kind === "tplExpr" || kind === "jsxExpr")) {
+        stack.pop();
+      }
+      prev = c === "}" && kind === "brace" ? "}" : "x";
+      i++;
+      continue;
+    }
+    if (ID_START.test(c)) {
+      let j = i + 1;
+      while (j < src.length && ID_PART.test(src.charAt(j))) j++;
+      prev = src.slice(i, j);
+      i = j;
+      continue;
+    }
+    if (/\s/.test(c)) {
+      i++;
+      continue;
+    }
+    if (/[0-9]/.test(c)) {
+      while (i < src.length && /[0-9A-Za-z_.]/.test(src.charAt(i))) i++;
+      prev = "x";
+      continue;
+    }
+    prev = c;
+    i++;
+  }
+  snap(src.length);
+  return snaps;
+  function openJsx(at) {
+    if (src[at + 1] === "/") {
+      stack.push({ kind: "jsxClose", start: at });
+      return at + 2;
+    }
+    let j = at + 1;
+    while (j < src.length && JSX_NAME_PART.test(src.charAt(j))) j++;
+    stack.push({ kind: "jsxTag", start: at, name: src.slice(at + 1, j) });
+    return j;
+  }
+  function afterJsxElement() {
+    prev = "x";
+  }
+}
+var COMMIT_WINDOW_MS = 1e4;
+var instances = /* @__PURE__ */ new WeakMap();
+function getDraftRoutes(server) {
+  return instances.get(server);
+}
+function createDraftRoutes(server, _model) {
+  const root = path6.resolve(server.config.root);
+  const vantageDir = path6.join(root, VANTAGE_DIR);
+  const pages = /* @__PURE__ */ new Map();
+  const committed = /* @__PURE__ */ new Map();
+  setDraftArtifacts(root, { hmr: true, pages: [] });
+  generateArtifacts({ root, model: scanProject(root) });
+  const toRel = (file) => {
+    const abs = path6.isAbsolute(file) ? file : path6.resolve(root, file);
+    return path6.relative(root, abs).split(path6.sep).join("/");
+  };
+  const describe = (rel) => {
+    if (rel === "" || rel.startsWith("../") || path6.isAbsolute(rel)) return null;
+    const pageRoot = resolvePageRoot(root);
+    const fromPageRoot = pageRoot.dir === "" ? rel : path6.posix.relative(pageRoot.dir, rel);
+    if (fromPageRoot.startsWith("../") || fromPageRoot === "") return null;
+    const parts = fromPageRoot.split("/");
+    if (parts.some((s) => NON_ROUTE_DIRS.has(s) || s.startsWith("."))) return null;
+    const base = parts[parts.length - 1];
+    const ext = PAGE_EXTENSIONS.find((e) => base.endsWith(e));
+    if (!ext) return null;
+    const nameNoExt = stripExt(base, PAGE_EXTENSIONS);
+    if (Object.values(RESERVED_PAGE_NAMES).includes(nameNoExt)) return null;
+    const { base: pageName, variant } = splitPageVariant(nameNoExt);
+    if (pageName.startsWith("_")) return null;
+    const relNoExt = stripExt(fromPageRoot, PAGE_EXTENSIONS);
+    const forSegments = variant ? relNoExt.slice(0, -(variant.length + 1)) : relNoExt;
+    const segments = fileToSegments(forSegments);
+    const dir = path6.posix.dirname(fromPageRoot);
+    return {
+      file: rel,
+      absFile: path6.join(root, ...rel.split("/")),
+      routePath: displayPath(segments),
+      segments,
+      dir: dir === "." ? "" : dir,
+      dynamic: segments.some((s) => s.kind !== "static"),
+      kind: "module",
+      ...variant ? { variant } : {}
+    };
+  };
+  const isNewPage = (file) => {
+    const page = describe(toRel(file));
+    return page !== null && !fs3.existsSync(page.absFile);
+  };
+  const rewrite = () => {
+    setDraftArtifacts(root, { hmr: true, pages: [...pages.values()] });
+    generateArtifacts({ root, model: scanProject(root) });
+  };
+  server.httpServer?.once("close", () => {
+    if (pages.size === 0) return;
+    pages.clear();
+    try {
+      rewrite();
+    } catch {
+    }
+  });
+  const resolvable = async (rel) => {
+    const container = server.environments?.client?.pluginContainer;
+    if (!container) return true;
+    try {
+      const importer = path6.join(vantageDir, "route-tree.gen.ts");
+      return await container.resolveId(`../${rel}`, importer) != null;
+    } catch {
+      return false;
+    }
+  };
+  const routes = {
+    isNewPage,
+    async ensure(file) {
+      const rel = toRel(file);
+      const page = describe(rel);
+      if (!page || fs3.existsSync(page.absFile)) return null;
+      if (pages.has(rel)) return { route: pages.get(rel).routePath };
+      const taken = [...scanProject(root).pages, ...pages.values()].some(
+        (p) => p.routePath === page.routePath && p.file !== rel
+      );
+      if (taken) return null;
+      if (!await resolvable(rel)) return null;
+      pages.set(rel, page);
+      rewrite();
+      return { route: page.routePath };
+    },
+    async release(file, { committed: wasCommitted }) {
+      const rel = toRel(file);
+      if (wasCommitted) committed.set(rel, Date.now() + COMMIT_WINDOW_MS);
+      if (!pages.delete(rel) && !wasCommitted) return;
+      rewrite();
+    },
+    isSuppressed(file) {
+      const rel = toRel(file);
+      if (pages.has(rel)) return true;
+      const until = committed.get(rel);
+      if (until === void 0) return false;
+      if (Date.now() <= until) return true;
+      committed.delete(rel);
+      return false;
+    }
+  };
+  instances.set(server, routes);
+  return routes;
+}
+
+// src/vite/draft/skeleton.ts
+var SKELETON = '<div data-vantage-skeleton className="animate-pulse rounded-md bg-muted" style={{ minHeight: "4rem", width: "100%" }} />';
+function declareMissingComponents(source, fileName) {
+  if (!/\.[jt]sx$/i.test(fileName)) return source;
+  const sf = parseSource(source, fileName);
+  const used = usedComponents(sf);
+  if (used.size === 0) return source;
+  const bound = boundNames(sf);
+  const typed = /\.tsx$/i.test(fileName);
+  const lines = [];
+  for (const [name, member] of used) {
+    if (bound.has(name)) continue;
+    lines.push(
+      member ? (
+        // `<Card.Header>`: every property of the placeholder is the placeholder.
+        `const ${name}${typed ? ": any" : ""} = new Proxy(function ${name}() { return ${SKELETON} }, { get: (target, key) => (typeof key === "string" ? target : undefined) })`
+      ) : `function ${name}(_props${typed ? ": any" : ""}) { return ${SKELETON} }`
+    );
+  }
+  if (lines.length === 0) return source;
+  return `${source}${source.endsWith("\n") ? "" : "\n"}${lines.join("\n")}
+`;
+}
+function relativeImports(source, fileName) {
+  const found = /* @__PURE__ */ new Map();
+  for (const stmt of parseSource(source, fileName).statements) {
+    if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier)) continue;
+    const specifier = stmt.moduleSpecifier.text;
+    if (!specifier.startsWith(".")) continue;
+    const names = found.get(specifier) ?? /* @__PURE__ */ new Set();
+    found.set(specifier, names);
+    const clause = stmt.importClause;
+    if (!clause || clause.isTypeOnly) continue;
+    if (clause.name) names.add("default");
+    if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+      for (const el of clause.namedBindings.elements) {
+        if (!el.isTypeOnly) names.add((el.propertyName ?? el.name).text);
+      }
+    }
+  }
+  return found;
+}
+function usedComponents(sf) {
+  const used = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+      let tag = node.tagName;
+      let member = false;
+      while (ts.isPropertyAccessExpression(tag)) {
+        tag = tag.expression;
+        member = true;
+      }
+      if (ts.isIdentifier(tag) && /^[A-Z]/.test(tag.text)) used.set(tag.text, member || (used.get(tag.text) ?? false));
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return used;
+}
+function draftTailwind(root) {
+  const dir = path6.join(root, VANTAGE_DIR, "draft-tailwind");
+  const runtimeCss = path6.join(root, VANTAGE_DIR, "runtime.css");
+  const mirrorOf = (file) => path6.join(dir, path6.relative(root, file).split(path6.sep).join("__"));
+  return {
+    stylesheet: runtimeCss,
+    owns: (file) => file.startsWith(dir + path6.sep),
+    reset() {
+      fs3.rmSync(dir, { recursive: true, force: true });
+      fs3.mkdirSync(dir, { recursive: true });
+    },
+    transformCss(code, id) {
+      if (id.split("?")[0] !== runtimeCss) return null;
+      return `${code}${code.endsWith("\n") ? "" : "\n"}@source ${JSON.stringify(dir)};
+`;
+    },
+    write(file, content) {
+      const mirror = mirrorOf(file);
+      if (fs3.existsSync(mirror) && fs3.readFileSync(mirror, "utf8") === content) return false;
+      fs3.writeFileSync(mirror, content);
+      return true;
+    },
+    remove(file) {
+      fs3.rmSync(mirrorOf(file), { force: true });
+    }
+  };
+}
+
+// src/vite/draft/visible.ts
+function renderedContent(source, fileName = "draft.tsx") {
+  const sf = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+  const component = defaultComponent(sf);
+  if (!component?.body) return null;
+  const roots = [];
+  if (ts.isBlock(component.body)) {
+    const visit = (node) => {
+      if (ts.isFunctionLike(node)) return;
+      if (ts.isReturnStatement(node) && node.expression) roots.push(node.expression);
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(component.body, visit);
+  } else {
+    roots.push(component.body);
+  }
+  if (roots.length === 0) return 0;
+  const jsxRoots = roots.map(unwrap).filter(isJsx);
+  if (jsxRoots.length < roots.length) return null;
+  let leaves = 0;
+  const count = (node) => {
+    if (ts.isJsxText(node)) {
+      if (node.text.trim() !== "") leaves++;
+      return;
+    }
+    if (ts.isJsxExpression(node)) {
+      if (node.expression && !ts.isJsxAttribute(node.parent)) leaves++;
+      return;
+    }
+    if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node)) {
+      if (isComponentTag(node.tagName) && node.attributes.properties.length > 0) leaves++;
+      return;
+    }
+    ts.forEachChild(node, count);
+  };
+  for (const root of jsxRoots) count(root);
+  return leaves;
+}
+function blanksScreen(next, shown) {
+  return renderedContent(next) === 0 && renderedContent(shown) !== 0;
+}
+function defaultComponent(sf) {
+  const functions = /* @__PURE__ */ new Map();
+  let exported;
+  for (const stmt of sf.statements) {
+    if (ts.isFunctionDeclaration(stmt)) {
+      const isDefault = stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+      if (isDefault) exported = stmt;
+      else if (stmt.name) functions.set(stmt.name.text, stmt);
+    } else if (ts.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        const init = decl.initializer && unwrap(decl.initializer);
+        if (ts.isIdentifier(decl.name) && init && (ts.isArrowFunction(init) || ts.isFunctionExpression(init)))
+          functions.set(decl.name.text, init);
+      }
+    } else if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
+      const expr = unwrap(stmt.expression);
+      if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) exported = expr;
+      else if (ts.isIdentifier(expr)) exported = expr.text;
+    }
+  }
+  return typeof exported === "string" ? functions.get(exported) : exported;
+}
+function unwrap(node) {
+  while (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node))
+    node = node.expression;
+  return node;
+}
+function isJsx(node) {
+  return ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node);
+}
+function isComponentTag(tag) {
+  return !ts.isIdentifier(tag) || /^[A-Z]/.test(tag.text);
+}
+
+// src/vite/draft/plugin.ts
+var DRAFT_ENDPOINT = "/__vantage_draft";
+var DRAFT_TOKEN_HEADER = "x-vantage-draft-token";
+var DRAFT_STATE_EVENT = "vantage:draft-state";
+var DRAFT_PAGE_EVENT = "vantage:draft-page";
+var DRAFT_PAGE_CLOSED_EVENT = "vantage:draft-page-closed";
+var DRAFT_RENDER_ERROR_EVENT = "vantage:draft-render-error";
+var DRAFT_SYNC_EVENT = "vantage:draft-sync";
+var DRAFT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"];
+var DRAFTABLE_EXTENSIONS = [".ts", ".tsx"];
+var MAX_BODY_BYTES = 1024 * 1024;
+var DRAFT_IDLE_DISCARD_MS = 6e4;
+var ROLLBACK_DEBOUNCE_MS = 150;
+var PREV_QUERY = "vantage-draft-prev";
+var SKELETON_PREFIX = "\0vantage-draft-skeleton:";
+function draftPreviewPlugin(options) {
+  const root = path6.resolve(options.root);
+  const token = options.token ?? process.env.VANTAGE_DRAFT_TOKEN;
+  const createRoutes = options.createRoutes ?? createDraftRoutes;
+  const idleDiscardMs = options.idleDiscardMs ?? DRAFT_IDLE_DISCARD_MS;
+  let enabled = false;
+  let tailwind;
+  let routes;
+  let server;
+  const drafts = /* @__PURE__ */ new Map();
+  const newFiles = /* @__PURE__ */ new Set();
+  const drafted = /* @__PURE__ */ new Set();
+  const ensuredPages = /* @__PURE__ */ new Map();
+  const lastSeq = /* @__PURE__ */ new Map();
+  const idleTimers = /* @__PURE__ */ new Map();
+  const rolledBackAt = /* @__PURE__ */ new Map();
+  const skeletons = /* @__PURE__ */ new Map();
+  const borrowed = new BorrowedVersions(PREV_QUERY);
+  let lastApplied;
+  let lastStateKey = "";
+  let queue = Promise.resolve();
+  const enqueue = (task) => {
+    const run = queue.then(task);
+    queue = run.catch(() => {
+    });
+    return run;
+  };
+  const waiting = [];
+  const isDraftRequest = (req) => !req.final && !req.discard;
+  const SUPERSEDED = { applied: false, reason: "superseded" };
+  const submit = (req) => new Promise((resolve, reject) => {
+    const key = typeof req.path === "string" && req.path !== "" ? path6.resolve(root, req.path) : void 0;
+    if (key !== void 0) {
+      if (!isDraftRequest(req)) {
+        for (let i = waiting.length - 1; i >= 0; i--) {
+          const job2 = waiting[i];
+          if (job2.key !== key || !isDraftRequest(job2.req)) continue;
+          waiting.splice(i, 1);
+          job2.settle(SUPERSEDED);
+        }
+      } else {
+        const last = waiting.findLast((job2) => job2.key === key);
+        if (last !== void 0 && isDraftRequest(last.req)) {
+          if (isOlder(req, last.req)) return resolve({ applied: false, reason: "stale" });
+          last.settle(SUPERSEDED);
+          last.req = req;
+          last.settle = resolve;
+          last.fail = reject;
+          return;
+        }
+      }
+    }
+    const job = { key, req, settle: resolve, fail: reject };
+    waiting.push(job);
+    void enqueue(async () => {
+      const at = waiting.indexOf(job);
+      if (at === -1) return;
+      waiting.splice(at, 1);
+      try {
+        job.settle(await apply(job.req));
+      } catch (err) {
+        job.fail(err);
+      }
+    });
+  });
+  const relOf = (file) => path6.relative(root, file).split(path6.sep).join("/");
+  const shown = (file) => drafts.get(file)?.at(-1);
+  const diskText = (file) => {
+    try {
+      return fs3.readFileSync(file, "utf8");
+    } catch {
+      return void 0;
+    }
+  };
+  const candidatesOf = (base) => [
+    base,
+    ...DRAFT_EXTENSIONS.map((ext) => base + ext),
+    ...DRAFT_EXTENSIONS.map((ext) => path6.join(base, "index" + ext))
+  ];
+  const skeletonId = (base) => {
+    const ext = path6.extname(base);
+    return SKELETON_PREFIX + (DRAFT_EXTENSIONS.includes(ext) ? base.slice(0, -ext.length) : base);
+  };
+  const isWritten = (base) => candidatesOf(base).some((c) => newFiles.has(c) || fs3.existsSync(c));
+  const registerSkeletons = (file, source, rel) => {
+    const grown = [];
+    const before = /* @__PURE__ */ new Map();
+    for (const [specifier, names] of relativeImports(source, rel)) {
+      const ext = path6.extname(specifier);
+      if (ext !== "" && !DRAFT_EXTENSIONS.includes(ext)) continue;
+      const base = path6.resolve(path6.dirname(file), specifier);
+      if (isWritten(base)) continue;
+      const id = skeletonId(base);
+      const known = skeletons.get(id);
+      if (!known) {
+        before.set(id, void 0);
+        skeletons.set(id, new Set(names));
+        grown.push(id);
+      } else if ([...names].some((n) => !known.has(n))) {
+        if (!before.has(id)) before.set(id, new Set(known));
+        for (const n of names) known.add(n);
+        grown.push(id);
+      }
+    }
+    const undo = () => {
+      for (const [id, names] of before) {
+        if (names === void 0) skeletons.delete(id);
+        else skeletons.set(id, names);
+      }
+    };
+    return { grown, undo };
+  };
+  const resolveTarget = (rel) => {
+    if (typeof rel !== "string" || rel === "") return "path is required";
+    const file = path6.resolve(root, rel);
+    const relPath = path6.relative(root, file);
+    if (relPath === "" || relPath.startsWith("..") || path6.isAbsolute(relPath)) return "path is outside the project";
+    const segments = relPath.split(path6.sep);
+    if (segments[0] === "server") return "server/ is not previewed";
+    if (segments.some((s) => s === "node_modules" || s.startsWith("."))) return "path is not a project source";
+    if (!DRAFTABLE_EXTENSIONS.includes(path6.extname(file))) return "only .ts and .tsx script modules are previewed";
+    const exists = fs3.existsSync(file);
+    if (exists && fs3.statSync(file).isDirectory()) return "path is a directory";
+    if (exists && !isInside(fs3.realpathSync(root), fs3.realpathSync(file))) return "path is outside the project";
+    return { file, rel: segments.join("/"), url: "/" + segments.join("/"), exists };
+  };
+  const modulesOf = (file) => [
+    ...server.environments.client.moduleGraph.getModulesByFile(file) ?? []
+  ].filter((mod) => mod.id !== null && !mod.url.includes(`${PREV_QUERY}=`));
+  const invalidate = (file) => {
+    const graph = server.environments.client.moduleGraph;
+    for (const mod of modulesOf(file)) graph.invalidateModule(mod);
+  };
+  const restyle = async () => {
+    const client = server.environments.client;
+    for (const mod of client.moduleGraph.getModulesByFile(tailwind.stylesheet) ?? []) await client.reloadModule(mod);
+  };
+  const reachable = (mod) => mod.importers.size > 0 || mod.isSelfAccepting === true;
+  const pushUpdate = async (file) => {
+    for (const mod of modulesOf(file)) if (reachable(mod)) await server.environments.client.reloadModule(mod);
+  };
+  const draftState = () => {
+    const files = [...drafts.keys()].map(relOf).sort();
+    return { active: files.length > 0, files };
+  };
+  const notifyState = () => {
+    const state = draftState();
+    const key = state.files.join("\n");
+    if (key === lastStateKey) return;
+    lastStateKey = key;
+    server.environments.client.hot.send(DRAFT_STATE_EVENT, state);
+  };
+  const sendState = (client) => {
+    (client ?? server.environments.client.hot).send(DRAFT_STATE_EVENT, draftState());
+  };
+  const forget = async (file, opts) => {
+    drafts.delete(file);
+    rolledBackAt.delete(file);
+    borrowed.drop(file);
+    tailwind.remove(file);
+    newFiles.delete(file);
+    clearTimeout(idleTimers.get(file));
+    idleTimers.delete(file);
+    const route = ensuredPages.get(file);
+    if (route === void 0) return;
+    ensuredPages.delete(file);
+    await routes.release(file, opts);
+    if (!opts.committed && !isDynamicRoute(route)) server.environments.client.hot.send(DRAFT_PAGE_CLOSED_EVENT, { route });
+  };
+  const touchIdle = (target) => {
+    clearTimeout(idleTimers.get(target.file));
+    const timer = setTimeout(() => {
+      idleTimers.delete(target.file);
+      void enqueue(() => discard(target)).catch(() => {
+      });
+    }, idleDiscardMs);
+    timer.unref();
+    idleTimers.set(target.file, timer);
+  };
+  const apply = async (req) => {
+    const target = resolveTarget(req.path);
+    if (typeof target === "string") return { applied: false, reason: target };
+    if (typeof req.seq === "number" && Number.isFinite(req.seq)) {
+      if (req.seq < (lastSeq.get(target.file) ?? -Infinity)) return { applied: false, reason: "stale" };
+      lastSeq.set(target.file, req.seq);
+    }
+    if (req.discard) return discard(target);
+    if (req.final) return finalize(target);
+    const result = await draft(target, req);
+    if (drafts.has(target.file)) touchIdle(target);
+    return result;
+  };
+  const finalize = async ({ file }) => {
+    if (!fs3.existsSync(file)) {
+      const had = drafts.has(file);
+      await forget(file, { committed: false });
+      invalidate(file);
+      notifyState();
+      return { applied: false, reason: had ? "file was not written" : "file does not exist" };
+    }
+    await forget(file, { committed: true });
+    notifyState();
+    invalidate(file);
+    await pushUpdate(file);
+    await refreshSkeletons([], file);
+    return { applied: true };
+  };
+  const discard = async ({ file }) => {
+    if (!drafts.has(file)) return { applied: false, reason: "no draft" };
+    await forget(file, { committed: false });
+    notifyState();
+    invalidate(file);
+    if (fs3.existsSync(file)) await pushUpdate(file);
+    return { applied: true };
+  };
+  const draft = async (target, req) => {
+    const { file, rel, url, exists } = target;
+    if (typeof req.content !== "string") return { applied: false, reason: "content is required" };
+    const pageDir = options.getModel().pageDir;
+    const previous = shown(file);
+    const base = previous?.served ?? diskText(file);
+    const page = isPageModule(rel, pageDir);
+    const newPage = !exists && page && routes.isNewPage(file);
+    const diskText0 = diskText(file);
+    const diskExports = page || diskText0 === void 0 ? /* @__PURE__ */ new Set() : exportNames(diskText0, rel);
+    const completedDraft = completeDraft(req.content, {
+      path: rel,
+      pageDir,
+      requireExport: page || diskExports.size === 0
+    });
+    if (completedDraft === null) return { applied: false, reason: "draft cannot be completed yet" };
+    const withSkeletons = declareMissingComponents(completedDraft, rel);
+    if (withSkeletons === previous?.completed) return { applied: true, reason: "unchanged" };
+    const undeclared = undeclaredNames(withSkeletons, rel);
+    if (undeclared.length > 0) return { applied: false, reason: `undeclared: ${undeclared.slice(0, 3).join(", ")}` };
+    if (page && base !== void 0 && blanksScreen(withSkeletons, base))
+      return { applied: false, reason: "renders nothing yet" };
+    let completed = withSkeletons;
+    let borrowSource;
+    if (!page) {
+      const have = exportNames(withSkeletons, rel);
+      const missing = [...diskExports].filter((name) => !have.has(name));
+      if (missing.length > 0) {
+        const source = borrowed.sourceFor(file, base);
+        const prevUrl = borrowed.urlFor(file, url, source);
+        completed = stubExports(withSkeletons, diskExports, prevUrl, rel);
+        if (completed.includes(prevUrl)) borrowSource = source;
+      }
+    }
+    if (completed === previous?.served) return { applied: true, reason: "unchanged" };
+    if (previous === void 0 && completed === diskText0) return { applied: true, reason: "unchanged" };
+    if (base !== void 0) {
+      const next = exportNames(completed, rel);
+      if ([...exportNames(base, rel)].some((name) => !next.has(name))) return { applied: false, reason: "missing-exports" };
+    }
+    const version = { served: completed, completed: withSkeletons, borrowSource };
+    drafted.add(file);
+    const history = drafts.get(file) ?? [];
+    drafts.set(file, [...history, version].slice(-8));
+    if (!exists) newFiles.add(file);
+    const { grown: grownSkeletons, undo: undoSkeletons } = registerSkeletons(file, completed, rel);
+    invalidate(file);
+    const revert = () => {
+      if (history.length === 0) {
+        drafts.delete(file);
+        newFiles.delete(file);
+      } else drafts.set(file, history);
+      undoSkeletons();
+      invalidate(file);
+    };
+    try {
+      await server.environments.client.transformRequest(url);
+    } catch (err) {
+      revert();
+      return { applied: false, reason: firstLine(err) };
+    }
+    await refreshSkeletons(grownSkeletons, exists ? void 0 : file);
+    let route;
+    if (newPage && !ensuredPages.has(file)) {
+      const ensured = await routes.ensure(file);
+      if (!ensured) {
+        revert();
+        return { applied: false, reason: "route could not be created" };
+      }
+      ensuredPages.set(file, ensured.route);
+      route = ensured.route;
+    }
+    borrowed.shown(file, borrowSource);
+    const styled = tailwind.write(file, completed);
+    lastApplied = file;
+    notifyState();
+    if (route !== void 0) {
+      if (!isDynamicRoute(route)) server.environments.client.hot.send(DRAFT_PAGE_EVENT, { route });
+      return { applied: true, route, created: true };
+    }
+    if (styled) await restyle();
+    await pushUpdate(file);
+    return { applied: true };
+  };
+  const refreshSkeletons = async (grown, written) => {
+    const graph = server.environments.client.moduleGraph;
+    for (const id of grown) {
+      const mod2 = graph.getModuleById(id);
+      if (!mod2) continue;
+      graph.invalidateModule(mod2);
+      await server.environments.client.reloadModule(mod2);
+    }
+    if (written === void 0) return;
+    const stand = skeletonId(written);
+    skeletons.delete(stand);
+    const mod = graph.getModuleById(stand);
+    if (!mod) return;
+    const importers = [...mod.importers];
+    graph.invalidateModule(mod);
+    for (const importer of importers) {
+      graph.invalidateModule(importer);
+      await server.environments.client.reloadModule(importer);
+    }
+  };
+  const renderError = async (data) => {
+    if (!enabled) return;
+    const file = (data.file ? locate(data.file) : void 0) ?? lastApplied;
+    const history = file === void 0 ? void 0 : drafts.get(file);
+    if (file === void 0 || history === void 0) return;
+    const now = Date.now();
+    if (now - (rolledBackAt.get(file) ?? 0) < ROLLBACK_DEBOUNCE_MS) return;
+    rolledBackAt.set(file, now);
+    history.pop();
+    const before = history.at(-1);
+    if (before === void 0) {
+      await forget(file, { committed: false });
+    } else {
+      borrowed.shown(file, before.borrowSource);
+      if (tailwind.write(file, before.served)) await restyle();
+    }
+    notifyState();
+    invalidate(file);
+    if (before !== void 0 || fs3.existsSync(file)) await pushUpdate(file);
+  };
+  const locate = (name) => {
+    const clean = name.split("?")[0];
+    const candidates = [path6.resolve(root, clean.replace(/^\//, "")), clean];
+    return candidates.find((c) => drafts.has(c));
+  };
+  const authorized = (req) => {
+    if (token === void 0 || token === "") return isLoopback(req) && !isForwarded(req);
+    const sent = req.headers[DRAFT_TOKEN_HEADER];
+    return typeof sent === "string" && sameSecret(sent, token);
+  };
+  const handle = async (req, res) => {
+    const send = (status, result) => {
+      res.statusCode = status;
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify(result));
+    };
+    if (!authorized(req)) {
+      const withToken = token !== void 0 && token !== "";
+      return send(withToken ? 401 : 403, { applied: false, reason: withToken ? "invalid token" : "loopback only" });
+    }
+    if ((token === void 0 || token === "") && !String(req.headers["content-type"]).startsWith("application/json"))
+      return send(415, { applied: false, reason: "content-type must be application/json" });
+    let body;
+    try {
+      body = JSON.parse(await readBody(req));
+    } catch (err) {
+      if (err instanceof BodyTooLarge) return send(413, { applied: false, reason: err.message });
+      return send(400, { applied: false, reason: firstLine(err) });
+    }
+    if (typeof body !== "object" || body === null || Array.isArray(body))
+      return send(400, { applied: false, reason: "body must be a JSON object" });
+    const request = body;
+    if (typeof request.path !== "string" || request.path === "")
+      return send(400, { applied: false, reason: "path is required" });
+    try {
+      const result = await submit(request);
+      send(result.applied === false && REFUSED_PATH.test(result.reason ?? "") ? 400 : 200, result);
+    } catch (err) {
+      send(500, { applied: false, reason: firstLine(err) });
+    }
+  };
+  return {
+    name: "vantage:draft-preview",
+    apply: "serve",
+    enforce: "pre",
+    api: { renderError },
+    async configureServer(s) {
+      if (!await loadTypeScript(root)) {
+        console.warn(
+          "[vantage] draft preview is off: `typescript` was not found in this project. Install it as a devDependency to preview unfinished files."
+        );
+        return;
+      }
+      enabled = true;
+      server = s;
+      routes = createRoutes(s, options.getModel());
+      tailwind = draftTailwind(root);
+      tailwind.reset();
+      s.middlewares.use(DRAFT_ENDPOINT, (req, res, next) => {
+        if (req.method !== "POST") return next();
+        if ((req.url ?? "/").split("?")[0] !== "/") {
+          res.statusCode = 404;
+          res.setHeader("Content-Type", "application/json");
+          return void res.end(JSON.stringify({ applied: false, reason: "not found" }));
+        }
+        void handle(req, res);
+      });
+      const hot = s.environments.client.hot;
+      hot.on(DRAFT_RENDER_ERROR_EVENT, (data) => {
+        void enqueue(() => renderError(data ?? {})).catch(() => {
+        });
+      });
+      hot.on(
+        "vite:client:connect",
+        (_data, client) => sendState(client)
+      );
+      hot.on(
+        DRAFT_SYNC_EVENT,
+        (_data, client) => sendState(client)
+      );
+    },
+    // A draft file that is not on disk yet still has to resolve for the modules importing it.
+    resolveId(source, importer) {
+      if (newFiles.size === 0 && skeletons.size === 0) return null;
+      const clean = source.split("?")[0];
+      let base;
+      if (clean.startsWith("/")) base = clean.startsWith(root + "/") ? clean : path6.join(root, clean);
+      else if (clean.startsWith(".") && importer) base = path6.resolve(path6.dirname(importer.split("?")[0]), clean);
+      else return null;
+      const written = candidatesOf(base);
+      const draftFile = written.find((c) => newFiles.has(c));
+      if (draftFile) return draftFile;
+      if (clean.startsWith(".") && importer && skeletons.size > 0) {
+        const id = skeletonId(base);
+        if (skeletons.has(id) && !written.some((c) => fs3.existsSync(c))) return id;
+      }
+      return null;
+    },
+    // Before @tailwindcss/vite reads the root stylesheet.
+    transform: {
+      order: "pre",
+      handler(code, id) {
+        return tailwind?.transformCss(code, id) ?? null;
+      }
+    },
+    load(id) {
+      if (id.startsWith(SKELETON_PREFIX)) return draftSkeletonModuleSource([...skeletons.get(id) ?? []]);
+      if (drafts.size === 0) return null;
+      const prev = new URLSearchParams(id.split("?")[1] ?? "").get(PREV_QUERY);
+      if (prev !== null) return borrowed.get(prev) ?? null;
+      return shown(id.split("?")[0])?.served ?? null;
+    },
+    // The borrowed versions share the drafted file but are not what changed.
+    hotUpdate({ modules, file }) {
+      if (tailwind?.owns(file)) return [];
+      if (enabled && file === path6.join(root, VANTAGE_DIR, "client-entry.tsx")) {
+        restoreClientEntry(root);
+        return [];
+      }
+      const kept = modules.filter(
+        (mod) => mod.id !== null && !mod.url.includes(`${PREV_QUERY}=`) && (!drafted.has(file) || reachable(mod))
+      );
+      if (kept.length !== modules.length) return kept;
+    }
+  };
+}
+function stubExports(source, expected, prevUrl, fileName) {
+  const have = exportNames(source, fileName);
+  const declared = topLevelNames(source, fileName);
+  const jsx = /\.tsx$/i.test(fileName);
+  const local = [];
+  const borrowed = [];
+  for (const name of expected) {
+    if (have.has(name)) continue;
+    if (name !== "default" && declared.has(name)) local.push(name);
+    else borrowed.push(name);
+  }
+  const isComponent = (name) => jsx && /^[A-Z]/.test(name);
+  const wrapped = borrowed.filter(isComponent);
+  const reexported = borrowed.filter((name) => !isComponent(name));
+  const stubs = [];
+  if (local.length) stubs.push(`export { ${local.join(", ")} }`);
+  if (reexported.length) stubs.push(`export { ${reexported.join(", ")} } from ${JSON.stringify(prevUrl)}`);
+  for (const name of wrapped) {
+    const alias = `__vantageDraftPrev_${name}`;
+    stubs.push(
+      `import { ${name} as ${alias} } from ${JSON.stringify(prevUrl)}`,
+      `export function ${name}(props: any) { return <${alias} {...props} /> }`
+    );
+  }
+  return stubs.length ? `${source}${source.endsWith("\n") ? "" : "\n"}${stubs.join("\n")}
+` : source;
+}
+function isInside(dir, file) {
+  const rel = path6.relative(dir, file);
+  return rel !== ".." && !rel.startsWith(".." + path6.sep) && !path6.isAbsolute(rel);
+}
+var REFUSED_PATH = /^path is a directory$/;
+function isDynamicRoute(route) {
+  return /[:*$]/.test(route);
+}
+function isOlder(a, b) {
+  return typeof a.seq === "number" && typeof b.seq === "number" && a.seq < b.seq;
+}
+function isForwarded(req) {
+  return Object.keys(req.headers).some((name) => name === "forwarded" || name.startsWith("x-forwarded-"));
+}
+function isLoopback(req) {
+  const addr = req.socket.remoteAddress;
+  return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
+}
+function sameSecret(a, b) {
+  const digest = (v) => createHash("sha256").update(v).digest();
+  return timingSafeEqual(digest(a), digest(b));
+}
+var BodyTooLarge = class extends Error {
+  constructor() {
+    super("draft is too large");
+  }
+};
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        chunks.length = 0;
+        reject(new BodyTooLarge());
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function firstLine(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return message.split("\n").find((l) => l.trim() !== "")?.trim() ?? "transform failed";
+}
+var PACKAGE_NAME = "@squadbase/vantage";
+var NOT_PREBUNDLED = /* @__PURE__ */ new Set([
+  "./server",
+  "./server/node",
+  "./vite",
+  "./theme.css",
+  "./package.json",
+  "./markdown",
+  "./table",
+  "./slide",
+  "./doc"
+]);
+function ownPackageDir() {
+  let dir = path6.dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    const manifest = path6.join(dir, "package.json");
+    if (fs3.existsSync(manifest)) {
+      try {
+        if (JSON.parse(fs3.readFileSync(manifest, "utf8")).name === PACKAGE_NAME) return dir;
+      } catch {
+      }
+    }
+    const parent = path6.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function packageName(spec) {
+  const parts = spec.split("/");
+  return spec.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function findPackageDir(fromDir, pkg) {
+  let dir = fromDir;
+  for (; ; ) {
+    const candidate = path6.join(dir, "node_modules", pkg);
+    if (fs3.existsSync(candidate)) return candidate;
+    const parent = path6.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function resolvesFrom(root, spec) {
+  const pkg = packageName(spec);
+  const dir = findPackageDir(root, pkg);
+  if (!dir) return false;
+  const sub = spec.slice(pkg.length);
+  if (sub === "") return true;
+  let exportsField;
+  try {
+    exportsField = JSON.parse(fs3.readFileSync(path6.join(dir, "package.json"), "utf8")).exports;
+  } catch {
+    return false;
+  }
+  if (exportsField && typeof exportsField === "object" && !Array.isArray(exportsField)) {
+    const keys = Object.keys(exportsField);
+    if (!keys.some((k) => k.startsWith("."))) return false;
+    const wanted = `.${sub}`;
+    return keys.some((key) => {
+      if (key === wanted) return true;
+      const star = key.indexOf("*");
+      if (star < 0) return false;
+      return wanted.startsWith(key.slice(0, star)) && wanted.endsWith(key.slice(star + 1));
+    });
+  }
+  const file = path6.join(dir, sub);
+  return [file, `${file}.js`, `${file}.mjs`, path6.join(file, "index.js")].some((f) => fs3.existsSync(f));
+}
+function isInstalled(root) {
+  const dir = findPackageDir(root, PACKAGE_NAME);
+  if (!dir) return false;
+  try {
+    return fs3.realpathSync(dir).split(path6.sep).includes("node_modules");
+  } catch {
+    return false;
+  }
+}
+function frameworkSubpaths(exportsField) {
+  return Object.keys(exportsField).filter((key) => key.startsWith(".") && !key.includes("*") && !NOT_PREBUNDLED.has(key)).map((key) => key === "." ? PACKAGE_NAME : `${PACKAGE_NAME}${key.slice(1)}`);
+}
+function bareImports(source) {
+  const out = /* @__PURE__ */ new Set();
+  const re = /(?:^|[\n;])\s*(?:import|export)\s+(type\s)?(?:[^'";]*?\sfrom\s*)?['"]([^'"\n]+)['"]/g;
+  for (const m of source.matchAll(re)) {
+    const [, typeOnly, spec] = m;
+    if (typeOnly || !spec || /^(\.|\/|node:|@\/|~|#)/.test(spec)) continue;
+    out.add(spec);
+  }
+  return [...out];
+}
+function registryDeps(registryDir) {
+  if (!fs3.existsSync(registryDir)) return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const name of fs3.readdirSync(registryDir)) {
+    if (!/\.(tsx?|jsx?)$/.test(name)) continue;
+    for (const spec of bareImports(fs3.readFileSync(path6.join(registryDir, name), "utf8"))) {
+      if (packageName(spec) !== PACKAGE_NAME) out.add(spec);
+    }
+  }
+  return [...out].sort();
+}
+function derivedDeps(root) {
+  const pkgDir = ownPackageDir();
+  if (!pkgDir) return [];
+  const out = registryDeps(path6.join(pkgDir, "registry", "ui"));
+  if (isInstalled(root)) {
+    try {
+      const manifest = JSON.parse(fs3.readFileSync(path6.join(pkgDir, "package.json"), "utf8"));
+      if (manifest.exports && typeof manifest.exports === "object") out.push(...frameworkSubpaths(manifest.exports));
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/vite/index.ts
+var DEDUPE = ["react", "react-dom", "@tanstack/react-router", "@tanstack/react-query"];
+var RUNTIME_DEPS = [
+  "react",
+  "react-dom",
+  "react-dom/client",
+  "react/jsx-runtime",
+  "@tanstack/react-router",
+  "@tanstack/react-query"
+];
+var KIT_DEPS = [
+  "@tanstack/react-table",
+  "class-variance-authority",
+  "clsx",
+  "cmdk",
+  "date-fns",
+  "date-fns/locale",
+  "echarts",
+  "lucide-react",
+  "react-day-picker",
+  "tailwind-merge",
+  "@base-ui/react/accordion",
+  "@base-ui/react/button",
+  "@base-ui/react/checkbox",
+  "@base-ui/react/collapsible",
+  "@base-ui/react/dialog",
+  "@base-ui/react/input",
+  "@base-ui/react/menu",
+  "@base-ui/react/merge-props",
+  "@base-ui/react/popover",
+  "@base-ui/react/progress",
+  "@base-ui/react/scroll-area",
+  "@base-ui/react/select",
+  "@base-ui/react/separator",
+  "@base-ui/react/slider",
+  "@base-ui/react/switch",
+  "@base-ui/react/tabs",
+  "@base-ui/react/toggle",
+  "@base-ui/react/toggle-group",
+  "@base-ui/react/tooltip",
+  "@base-ui/react/use-render"
+];
+function optimizeInclude(root, extra) {
+  return [.../* @__PURE__ */ new Set([...RUNTIME_DEPS, ...KIT_DEPS, ...derivedDeps(root), ...extra])].filter(
+    (spec) => resolvesFrom(root, spec)
+  );
+}
+var FILE_PAGE_DEPS = ["papaparse", "read-excel-file/browser"];
+var SLIDE_EXPORT_DEPS = ["html-to-image", "fflate"];
+function conditionalDeps(model) {
+  return [
+    ...model.pages.some((p) => p.kind === "file") ? FILE_PAGE_DEPS : [],
+    ...model.pages.some((p) => p.variant === "slide") ? SLIDE_EXPORT_DEPS : []
+  ];
+}
+function underPageRoot(pageRoot, file) {
+  const rel = path6.relative(pageRoot, file);
+  if (rel.startsWith("..")) return false;
+  const segments = rel.split(path6.sep);
+  return !segments.some((s) => NON_ROUTE_DIRS.has(s) || s.startsWith(".") && s !== "..");
+}
+function isPageModuleFile(pageRoot, file) {
+  return underPageRoot(pageRoot, file) && PAGE_EXTENSIONS.some((ext) => file.endsWith(ext));
+}
+function isRoutedFile(pageRoot, file) {
+  return isPageModuleFile(pageRoot, file) || isFilePageFile(pageRoot, file);
+}
+function isFilePageFile(pageRoot, file) {
+  const lower = file.toLowerCase();
+  return underPageRoot(pageRoot, file) && FILE_PAGE_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+function isApiFile(root, file) {
+  const rel = path6.relative(root, file);
+  return rel.startsWith(`server${path6.sep}api${path6.sep}`) && /\.(ts|tsx|js)$/.test(file) && !file.endsWith(".d.ts");
+}
+function isServerFile(root, file) {
+  const rel = path6.relative(root, file);
+  return rel === "server" || rel.startsWith(`server${path6.sep}`);
+}
+function vantagePlugin(options) {
+  const root = path6.resolve(options.root);
+  const vantageDir = path6.join(root, VANTAGE_DIR);
+  let model = options.model ?? scanProject(root);
+  let generated = Boolean(options.artifactsWritten);
+  let shellHtml = null;
+  const pageRoot = () => model.pageDir === "" ? root : path6.join(root, model.pageDir);
+  const emit = () => {
+    generateArtifacts({ root, model });
+    generated = true;
+    shellHtml = null;
+  };
+  const ensureGenerated = () => {
+    if (!generated) emit();
+  };
+  const regenerate = () => {
+    model = scanProject(root);
+    emit();
+  };
+  const core = {
+    name: "vantage:core",
+    enforce: "pre",
+    config() {
+      return {
+        root,
+        appType: "custom",
+        envPrefix: ["PUBLIC_"],
+        resolve: { dedupe: DEDUPE },
+        optimizeDeps: { include: optimizeInclude(root, conditionalDeps(model)) },
+        server: {
+          // Browser console + runtime errors belong in the dev terminal: it is
+          // the feedback surface both humans and agents already watch. Vite 8
+          // forwards them natively — with source-mapped stacks and code frames,
+          // which the hand-rolled beacon bridge this replaces could not do — but
+          // only turns itself on when it detects an agent. Vantage wants it
+          // always. warn/error only: forwarding `log`/`info` too lets one chatty
+          // render loop bury the server's own output.
+          forwardConsole: { unhandledErrors: true, logLevels: ["warn", "error"] }
+        },
+        build: {
+          outDir: path6.join(root, "dist", "client"),
+          emptyOutDir: true,
+          rollupOptions: {
+            input: path6.join(vantageDir, "index.html")
+          }
+        }
+      };
+    },
+    configResolved() {
+      ensureGenerated();
+    },
+    buildStart() {
+      ensureGenerated();
+    },
+    // --- 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 = path6.relative(root, imp);
+      if (relImp.startsWith(`server${path6.sep}`) || relImp.startsWith(VANTAGE_DIR) || relImp.includes("node_modules")) {
+        return null;
+      }
+      let target = null;
+      if (source.startsWith(".")) target = path6.resolve(path6.dirname(imp), source);
+      else if (source.startsWith("/")) target = path6.join(root, source.slice(1));
+      else if (source === "server" || source.startsWith("server/")) target = path6.join(root, source);
+      if (!target) return null;
+      const relTarget = path6.relative(root, target);
+      if (relTarget === "server" || relTarget.startsWith(`server${path6.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 (!isPageModuleFile(pageRoot(), 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 };
+    },
+    configureServer(server) {
+      const getEnv = () => options.env ?? process.env;
+      const apiMw = createApiDevMiddleware({ server, getModel: () => model, getEnv });
+      server.middlewares.use((req, res, next) => {
+        if (model.hasServer) return apiMw(req, res, next);
+        return next();
+      });
+      const isStylesFile = (file) => path6.relative(pageRoot(), file) === "styles.css";
+      const rootMoved = () => resolvePageRoot(root).dir !== model.pageDir;
+      const onStructural = (file) => {
+        const moved = rootMoved();
+        if (moved || isRoutedFile(pageRoot(), file) || isApiFile(root, file) || isStylesFile(file)) {
+          regenerate();
+          if (!moved && getDraftRoutes(server)?.isSuppressed(file)) return;
+          server.ws.send({ type: "full-reload" });
+        }
+      };
+      const isRouteDir = (dir) => {
+        if (isServerFile(root, dir)) return true;
+        const rel = path6.relative(pageRoot(), dir);
+        if (rel === "" || rel.startsWith("..")) return false;
+        return !rel.split(path6.sep).some((s) => NON_ROUTE_DIRS.has(s) || s.startsWith("."));
+      };
+      server.watcher.on("add", onStructural);
+      server.watcher.on("unlink", onStructural);
+      server.watcher.on("addDir", (dir) => {
+        if (rootMoved() || isRouteDir(dir)) regenerate();
+      });
+      server.watcher.on("unlinkDir", (dir) => {
+        if (!rootMoved() && !isRouteDir(dir)) return;
+        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;
+        }
+        if (isFilePageFile(pageRoot(), file)) server.ws.send({ type: "full-reload" });
+      });
+      return () => {
+        server.middlewares.use(async (req, res, next) => {
+          if (req.method !== "GET" && req.method !== "HEAD") return next();
+          try {
+            if (shellHtml === null) {
+              const raw = fs3.readFileSync(path6.join(vantageDir, "index.html"), "utf8");
+              const shellUrl = `/${VANTAGE_DIR}/index.html`;
+              shellHtml = await server.transformIndexHtml(shellUrl, raw, req.originalUrl);
+            }
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "text/html");
+            res.end(shellHtml);
+          } catch (err) {
+            next(err);
+          }
+        });
+      };
+    }
+  };
+  const draft = options.draftPreview ? draftPreviewPlugin({
+    root,
+    getModel: () => model,
+    token: typeof options.draftPreview === "object" ? options.draftPreview.token : void 0
+  }) : void 0;
+  return [core, ...draft ? [draft] : [], react(), tailwindcss()];
+}
+
+export { vantagePlugin };
+//# sourceMappingURL=chunk-2ICNHUG6.js.map
+//# sourceMappingURL=chunk-2ICNHUG6.js.map