@beastjs/page-builder 0.0.0-stage → 0.1.0

package/dist/rsbuild.js

@@ -0,0 +1,883 @@
+// server/server.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+// shared/types.ts
+var BASE = "/__beast-page-builder";
+
+// server/project.ts
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, mkdir, readdir, readFile, realpath, writeFile, unlink, link, rename, stat, chmod } from "node:fs/promises";
+import { basename, dirname as dirname2, isAbsolute, relative as relative2, resolve as resolve2, sep } from "node:path";
+import { compileBeastResult as compileBeastResult3, componentNameFromPath } from "beast-tsrx";
+import { createOctaneCompiler } from "octane/compiler/bundler";
+
+// server/integration.ts
+import ts from "typescript";
+import { compileBeastResult } from "beast-tsrx";
+import { dirname, relative } from "node:path";
+var apply = (source, edits) => edits.sort((a, b) => b.start - a.start).reduce((text, edit) => text.slice(0, edit.start) + edit.text + text.slice(edit.end), source);
+var quote = (value) => JSON.stringify(value);
+var newline = (source) => source.includes("\r\n") ? "\r\n" : "\n";
+var property = (node, name) => node.properties.find((prop) => ts.isPropertyAssignment(prop) && (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) && prop.name.text === name)?.initializer;
+var literal = (node) => node && ts.isStringLiteral(node) ? node.text : void 0;
+var unwrap = (node) => ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isParenthesizedExpression(node) ? unwrap(node.expression) : node;
+function parseTypeScript(source, file) {
+  const ast = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  const diagnostics = ast.parseDiagnostics;
+  if (diagnostics.length) throw new BuilderError(`${file}: ${ts.flattenDiagnosticMessageText(diagnostics[0].messageText, "\n")}`, 422);
+  return ast;
+}
+function appendArray(source, array, item) {
+  const close = array.end - 1;
+  const lineStart = source.lastIndexOf("\n", close - 1) + 1;
+  const closingIndent = source.slice(lineStart, close);
+  const multiline = array.getText().includes("\n") && /^\s*$/.test(closingIndent);
+  const edits = [];
+  const last = array.elements.at(-1);
+  if (last && last.end === close && !multiline) return [{ start: close, end: close, text: `, ${item}` }];
+  if (last && !array.elements.hasTrailingComma) edits.push({ start: last.end, end: last.end, text: "," });
+  edits.push({ start: multiline ? lineStart : close, end: multiline ? lineStart : close, text: multiline ? `${closingIndent}  ${item},${newline(source)}` : `${last ? " " : ""}${item}${array.elements.hasTrailingComma ? "," : ""}` });
+  return edits;
+}
+function registerRoute(source, file, pageFile, name, path) {
+  const ast = parseTypeScript(source, file);
+  const routerImport = ast.statements.find((statement) => ts.isImportDeclaration(statement) && literal(statement.moduleSpecifier) === "@octanejs/tanstack-router");
+  const bindings = routerImport?.importClause?.namedBindings;
+  if (!bindings || !ts.isNamedImports(bindings)) throw new BuilderError(`${file} must import createRoute from @octanejs/tanstack-router.`, 422);
+  const binding = (name2) => bindings.elements.find((item) => (item.propertyName ?? item.name).text === name2 && !item.isTypeOnly)?.name.text;
+  const createRoute = binding("createRoute");
+  if (!createRoute) throw new BuilderError(`${file} must import createRoute.`, 422);
+  const trees = [];
+  const components = [];
+  const identifiers = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (ts.isIdentifier(node)) identifiers.add(node.text);
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === createRoute) {
+      const options = node.arguments[0];
+      if (!options || !ts.isObjectLiteralExpression(options)) throw new BuilderError("Computed route options are unsupported. Use a literal createRoute object.", 422);
+      const routePath = property(options, "path");
+      if (routePath && !literal(routePath)) throw new BuilderError("Computed route paths cannot be checked for conflicts.", 422);
+      const existing = literal(routePath);
+      if (existing && "/" + existing.replace(/^\/+|\/+$/g, "") === path) throw new BuilderError(`Route ${path} already exists.`, 409);
+      const component = property(options, "component");
+      if (component && ts.isCallExpression(component) && ts.isIdentifier(component.expression)) components.push(component.expression.text);
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(ast);
+  for (const statement of ast.statements) if (ts.isVariableStatement(statement)) {
+    for (const declaration2 of statement.declarationList.declarations) {
+      const call = declaration2.initializer;
+      if (!call || !ts.isCallExpression(call) || !ts.isPropertyAccessExpression(call.expression) || call.expression.name.text !== "addChildren" || !ts.isIdentifier(call.expression.expression)) continue;
+      const array = call.arguments[0];
+      if (!array || !ts.isArrayLiteralExpression(array) || array.elements.some(ts.isSpreadElement)) throw new BuilderError("The root route must use addChildren with a literal array of routes.", 422);
+      trees.push({ statement, call, array, root: call.expression.expression.text });
+    }
+  }
+  if (trees.length !== 1) throw new BuilderError(`${file} needs one rootRoute.addChildren([...]) route tree.`, 422);
+  const tree = trees[0];
+  let lazy = binding("lazyRouteComponent");
+  if (components.includes("lazyPage") && ast.statements.some((statement) => ts.isFunctionDeclaration(statement) && statement.name?.text === "lazyPage")) lazy = "lazyPage";
+  const edits = [];
+  if (!lazy) {
+    lazy = "lazyRouteComponent";
+    if (identifiers.has(lazy)) throw new BuilderError("lazyRouteComponent conflicts with an existing binding.", 422);
+    const last = bindings.elements.at(-1);
+    const at = last && !bindings.elements.hasTrailingComma ? last.end : bindings.end - 1;
+    edits.push({ start: at, end: at, text: last && !bindings.elements.hasTrailingComma ? ", lazyRouteComponent" : ` lazyRouteComponent${last ? "," : ""} ` });
+  }
+  let routeName = name[0].toLowerCase() + name.slice(1) + "Route";
+  const baseName = routeName;
+  for (let suffix = 2; identifiers.has(routeName); suffix++) routeName = baseName + suffix;
+  let modulePath = relative(dirname(file), pageFile).replaceAll("\\", "/");
+  if (!modulePath.startsWith(".")) modulePath = "./" + modulePath;
+  const declaration = `const ${routeName} = ${createRoute}({ getParentRoute: () => ${tree.root}, path: ${quote(path)}, component: ${lazy}(() => import(${quote(modulePath)})) })${newline(source)}${newline(source)}`;
+  edits.push({ start: tree.statement.getStart(ast), end: tree.statement.getStart(ast), text: declaration }, ...appendArray(source, tree.array, routeName));
+  const result = apply(source, edits);
+  parseTypeScript(result, file);
+  return result;
+}
+function inlineTargets(source, file) {
+  const ast = compileBeastResult(source, { filename: file }).ast;
+  const targets = [];
+  function walk(value) {
+    if (!value || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      value.forEach(walk);
+      return;
+    }
+    const object = value;
+    if (object.kind === "element" && object.tag === "nav") {
+      const node = value;
+      if (!node.attrs.some((attr) => attr.kind === "attribute" && attr.name === "role" && attr.value.type === "string" && attr.value.value === "tablist") && node.children.every((child) => child.kind === "element" && ["a", "Link"].includes(child.tag))) {
+        const selector = "nav" + (node.id ? `#${node.id}` : "") + node.classes.map((name) => `.${name}`).join("");
+        targets.push({ id: `btsx:${file}:${node.lineNo}`, file, label: `${file} \xB7 ${selector}`, node });
+      }
+    }
+    for (const [key, child] of Object.entries(object)) if (["children", "branches", "declarations"].includes(key)) walk(child);
+  }
+  walk(ast);
+  return targets;
+}
+function arrayTargets(source, file, config) {
+  const ast = parseTypeScript(source, file);
+  const targets = [];
+  for (const statement of ast.statements) if (ts.isVariableStatement(statement)) {
+    if (!statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+      const name = declaration.name.text;
+      if (config?.array ? name !== config.array : !/^(navItems|navGroups|navigation|links)$/.test(name)) continue;
+      const array = unwrap(declaration.initializer);
+      if (!ts.isArrayLiteralExpression(array) || array.elements.some(ts.isSpreadElement)) continue;
+      const objects = array.elements.filter(ts.isObjectLiteralExpression);
+      const groups = objects.filter((object) => property(object, "items"));
+      if (groups.length) {
+        for (const group of groups) {
+          const title = literal(property(group, "title")) ?? literal(property(group, "label"));
+          const items = property(group, "items");
+          if (!title || !items || !ts.isArrayLiteralExpression(unwrap(items)) || unwrap(items).elements.some(ts.isSpreadElement) || config?.group && config.group !== title) continue;
+          targets.push({ id: `ts:${file}:${name}:${title}`, file, label: `${file} \xB7 ${name} / ${title}`, array: unwrap(items) });
+        }
+      } else if (!config?.group && objects.length === array.elements.length) targets.push({ id: `ts:${file}:${name}`, file, label: `${file} \xB7 ${name}`, array });
+    }
+  }
+  return targets;
+}
+function discoverNavigation(source, file, config) {
+  if (file.endsWith(".btsx")) return inlineTargets(source, file).filter((target) => !config?.selector || target.label.endsWith(` \xB7 ${config.selector}`)).map(({ node, ...target }) => target);
+  return arrayTargets(source, file, config).map(({ array, ...target }) => target);
+}
+function addNavigation(source, target, path, label, config) {
+  if (target.file.endsWith(".btsx")) {
+    let end2 = function(node) {
+      lastLine = Math.max(lastLine, node.span.end.line);
+      for (const child of node.children) if (child.kind === "element") end2(child);
+      else lastLine = Math.max(lastLine, child.span.end.line);
+    };
+    var end = end2;
+    const nav = inlineTargets(source, target.file).find((item2) => item2.id === target.id)?.node;
+    if (!nav) throw new BuilderError("The selected navigation changed. Rescan the project.", 409);
+    const links = nav.children;
+    if (links.some((link3) => link3.attrs.some((attr) => attr.kind === "attribute" && ["href", "to"].includes(attr.name) && attr.value.type === "string" && attr.value.value.replace(/\/$/, "") === path))) throw new BuilderError(`Navigation already links to ${path}.`, 409);
+    const link2 = links.find((link3) => link3.tag === "Link");
+    const indent = " ".repeat(nav.span.start.column - 1 + 2);
+    const classes = (link2?.classes ?? links[0]?.classes ?? []).filter((name) => !/active|selected/.test(name));
+    const classAttr = link2?.attrs.find((attr) => attr.kind === "attribute" && attr.name === "className" && attr.value.type === "string");
+    const classValue = classAttr?.kind === "attribute" && classAttr.value.type === "string" ? ` className=${quote(classAttr.value.value)}` : "";
+    let lastLine = nav.span.end.line;
+    links.forEach(end2);
+    const lines = source.split(/\r?\n/);
+    lines.splice(lastLine, 0, `${indent}${link2 ? "Link" : "a"}${classes.map((name) => "." + name).join("")}(${link2 ? "to" : "href"}=${quote(path)}${classValue}) #{${quote(label)}}`);
+    return lines.join(newline(source));
+  }
+  const array = arrayTargets(source, target.file, { ...config, file: target.file, array: target.array ?? config?.array, group: target.group ?? config?.group }).find((item2) => item2.id === target.id)?.array;
+  if (!array) throw new BuilderError("The selected navigation changed. Rescan the project.", 409);
+  const objects = array.elements.filter(ts.isObjectLiteralExpression);
+  if (objects.some((object) => [property(object, "href"), property(object, "to")].some((value) => literal(value)?.replace(/\/$/, "") === path))) throw new BuilderError(`Navigation already links to ${path}.`, 409);
+  const template = objects.find((object) => property(object, "href") || property(object, "to")) ?? objects[0];
+  const contract = target.itemType?.variants?.find((variant) => variant.fields.some((field2) => ["href", "to"].includes(field2.name))) ?? target.itemType;
+  const defaults = config?.itemDefaults ?? {};
+  const fields = { ...defaults };
+  let keys = template ? template.properties.map((prop) => prop.name && (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) ? prop.name.text : "") : ["href", "label"];
+  if (contract?.fields.length) keys = [.../* @__PURE__ */ new Set([...template ? keys : [], ...contract.fields.filter((field2) => !field2.optional).map((field2) => field2.name)])];
+  if (keys.includes("") || template?.properties.some((prop) => !ts.isPropertyAssignment(prop))) throw new BuilderError("Menu items must be literal objects with named fields.", 422);
+  for (const key of keys) {
+    if (key in defaults) continue;
+    if (key === "href" || key === "to") fields[key] = path;
+    else if (["label", "title", "short", "description"].includes(key)) fields[key] = label;
+    else if (key === "value" || key === "id") fields[key] = path.slice(1);
+    else if (key === "tags") fields[key] = [label.toLowerCase()];
+    else if (key === "disabled") fields[key] = false;
+    else if (["kind", "type"].includes(key) && template && literal(property(template, key))) fields[key] = literal(property(template, key));
+    else if (key === "icon" && template && literal(property(template, key))) fields[key] = literal(property(template, key));
+    else throw new BuilderError(`Set navigation.itemDefaults.${key} for this menu.`, 422);
+  }
+  fields[keys.includes("to") ? "to" : "href"] = path;
+  fields[keys.includes("title") && !keys.includes("label") ? "title" : "label"] = label;
+  for (const fieldContract of contract?.origin === "declared" ? contract.fields : []) {
+    if (!(fieldContract.name in fields)) continue;
+    const value = fields[fieldContract.name];
+    const type = fieldContract.type.replace(/ \| undefined/g, "");
+    if (fieldContract.values?.length && !fieldContract.values.includes(value) && !/(?:^| \| )(?:string|number|boolean)(?:$| \| )/.test(type)) throw new BuilderError(`navigation.itemDefaults.${fieldContract.name} must match ${fieldContract.type}.`, 422);
+    if (type === "string" && typeof value !== "string" || type === "number" && typeof value !== "number" || type === "boolean" && typeof value !== "boolean" || type === "string[]" && (!Array.isArray(value) || value.some((item2) => typeof item2 !== "string"))) throw new BuilderError(`navigation.itemDefaults.${fieldContract.name} must be ${type}.`, 422);
+  }
+  const item = `{ ${Object.entries(fields).map(([key, value]) => `${quote(key)}: ${JSON.stringify(value)}`).join(", ")} }`;
+  const result = apply(source, appendArray(source, array, item));
+  parseTypeScript(result, target.file);
+  return result;
+}
+
+// server/discovery.ts
+import ts2 from "typescript";
+import { resolve } from "node:path";
+import { compileBeastResult as compileBeastResult2 } from "beast-tsrx";
+var unbox = (node) => ts2.isAsExpression(node) || ts2.isSatisfiesExpression(node) || ts2.isParenthesizedExpression(node) ? unbox(node.expression) : node;
+var nameOf = (node) => node && (ts2.isIdentifier(node) || ts2.isStringLiteral(node)) ? node.text : void 0;
+var field = (node, name) => node.properties.find((prop) => ts2.isPropertyAssignment(prop) && nameOf(prop.name) === name)?.initializer;
+var textOf = (node) => node && (ts2.isStringLiteralLike(node) || ts2.isNumericLiteral(node)) ? node.text : void 0;
+var attribute = (node, name) => node.attrs.find((attr) => attr.kind === "attribute" && attr.name === name);
+var attrText = (node, name) => {
+  const attr = attribute(node, name);
+  return attr?.kind === "attribute" && attr.value.type === "string" ? attr.value.value : void 0;
+};
+var itemKind = (destination) => !destination ? "unknown" : destination.startsWith("#") ? "anchor" : /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(destination) ? "external-link" : "internal-link";
+var inferExpression = (code) => /^['"`]/.test(code.trim()) ? "string" : /^(?:true|false)$/.test(code.trim()) ? "boolean" : /^-?\d+(?:\.\d+)?$/.test(code.trim()) ? "number" : /=>|^function\b/.test(code.trim()) ? "function" : "unknown";
+function virtualBeast(input, root) {
+  const document = compileBeastResult2(input.source, { filename: input.file }).ast;
+  const code = [], lines = [];
+  function add(text, line = 1) {
+    text.split("\n").forEach((text2, index) => {
+      code.push(text2);
+      lines.push(line + index);
+    });
+  }
+  for (const declaration of document.declarations) {
+    if (declaration.kind === "import") add(declaration.code, declaration.lineNo);
+    else if (declaration.kind === "module") add(declaration.code, declaration.codeStart.line);
+  }
+  const props = document.declarations.find((declaration) => declaration.kind === "props");
+  add(`declare function __BeastComponent(${props?.kind === "props" ? props.parameter.replace(/;$/, "") : "props: unknown"}): unknown;
+export default __BeastComponent;`);
+  add("function __beastSetup() {");
+  for (const declaration of document.declarations) if (declaration.kind === "setup") add(declaration.code, declaration.codeStart.line);
+  add("}");
+  for (const declaration of document.declarations) if (declaration.kind === "component") {
+    add(`function ${declaration.name}(${declaration.props?.parameter.replace(/;$/, "") ?? ""}) {`, declaration.lineNo);
+    for (const setup of declaration.setup) add(setup.code, setup.codeStart.line);
+    add("}");
+  }
+  return { ...input, document, virtual: resolve(root, input.file + ".ts"), text: code.join("\n"), lines };
+}
+function discoverCollections(root, sources) {
+  const inputs = sources.flatMap((source) => {
+    try {
+      return [source.file.endsWith(".btsx") ? virtualBeast(source, root) : { ...source, virtual: resolve(root, source.file), text: source.source }];
+    } catch {
+      return [];
+    }
+  });
+  const collections = [];
+  const references = [];
+  const byVirtual = new Map(inputs.map((input) => [input.virtual, input]));
+  let options = { target: ts2.ScriptTarget.ESNext, module: ts2.ModuleKind.ESNext, moduleResolution: ts2.ModuleResolutionKind.Bundler, strict: true, skipLibCheck: true, noEmit: true };
+  const configPath = ts2.findConfigFile(root, ts2.sys.fileExists);
+  if (configPath) {
+    const config = ts2.readConfigFile(configPath, ts2.sys.readFile);
+    if (!config.error) options = { ...options, ...ts2.parseJsonConfigFileContent(config.config, ts2.sys, resolve(configPath, "..")).options, noEmit: true };
+  }
+  const host = ts2.createCompilerHost(options);
+  const read = host.readFile.bind(host), exists = host.fileExists.bind(host);
+  host.readFile = (file) => byVirtual.get(resolve(file))?.text ?? read(file);
+  host.fileExists = (file) => byVirtual.has(resolve(file)) || exists(file);
+  const program = ts2.createProgram(inputs.map((input) => input.virtual), options, host);
+  const checker = program.getTypeChecker();
+  const lineOf = (input, node) => {
+    const line = node.getSourceFile().getLineAndCharacterOfPosition(node.getStart()).line;
+    return input.lines?.[line] ?? line + 1;
+  };
+  function typeSchema(type, at, declared, variants = true) {
+    const flags = ts2.TypeFormatFlags.NoTruncation;
+    const typeName = (type2) => checker.typeToString(type2, at, flags).replace(/import\("[^"]+"\)\./g, "");
+    const members = type.isUnion() ? type.types : [type];
+    if (members.every((member) => member.flags & (ts2.TypeFlags.StringLike | ts2.TypeFlags.NumberLike | ts2.TypeFlags.BooleanLike | ts2.TypeFlags.Null | ts2.TypeFlags.Undefined | ts2.TypeFlags.Any | ts2.TypeFlags.Unknown))) return { name: typeName(type), origin: declared && !(type.flags & (ts2.TypeFlags.Any | ts2.TypeFlags.Unknown)) ? "declared" : "inferred", fields: [] };
+    const symbols = new Map(members.flatMap((member) => member.getProperties().map((symbol) => [symbol.name, symbol])));
+    const fields = [...symbols].filter(([name]) => !name.startsWith("__@")).map(([name]) => {
+      const properties = members.map((member) => member.getProperty(name));
+      const types = properties.flatMap((symbol) => symbol ? [checker.getTypeOfSymbolAtLocation(symbol, at)] : []);
+      const values = types.flatMap((type2) => (type2.isUnion() ? type2.types : [type2]).flatMap((value) => value.isStringLiteral() || value.isNumberLiteral() ? [value.value] : value.flags & ts2.TypeFlags.BooleanLiteral ? [checker.typeToString(value) === "true"] : []));
+      return { name, type: [...new Set(types.map((type2) => typeName(type2)))].join(" | "), optional: properties.some((symbol) => !symbol || !!(symbol.flags & ts2.SymbolFlags.Optional)), ...values.length ? { values: [...new Set(values)] } : {} };
+    });
+    const known = !(type.flags & (ts2.TypeFlags.Any | ts2.TypeFlags.Unknown)) && fields.length > 0;
+    return { name: typeName(type), origin: declared && known ? "declared" : "inferred", fields, ...variants && type.isUnion() && type.types.every((type2) => type2.getProperties().length) ? { variants: type.types.map((member) => typeSchema(member, at, declared, false)) } : {} };
+  }
+  function elementType(array) {
+    const contextual = checker.getContextualType(array);
+    return contextual && checker.getIndexTypeOfType(contextual, ts2.IndexKind.Number) || checker.getIndexTypeOfType(checker.getTypeAtLocation(array), ts2.IndexKind.Number);
+  }
+  function declaredType(array) {
+    let node = array;
+    while (!ts2.isSourceFile(node)) {
+      if (ts2.isVariableDeclaration(node)) return !!node.type || !!(node.initializer && (ts2.isSatisfiesExpression(node.initializer) || ts2.isAsExpression(node.initializer) && node.initializer.type.getText() !== "const"));
+      node = node.parent;
+    }
+    return false;
+  }
+  function narrowedType(object, context) {
+    if (context?.isUnion()) {
+      const candidates = context.types.filter((member) => object.properties.every((prop) => {
+        if (!ts2.isPropertyAssignment(prop) || !ts2.isStringLiteralLike(prop.initializer)) return true;
+        const symbol = member.getProperty(nameOf(prop.name) ?? "");
+        if (!symbol) return false;
+        const type = checker.getTypeOfSymbolAtLocation(symbol, object);
+        return !type.isStringLiteral() || type.value === prop.initializer.text;
+      }));
+      if (candidates.length === 1) return candidates[0];
+    }
+    return context && !context.isUnion() && context.getProperties().length ? context : checker.getTypeAtLocation(object);
+  }
+  for (const input of inputs) if (input.document) {
+    let schemaOfControl2 = function(node) {
+      const symbol = checker.resolveName(node.tag, file, ts2.SymbolFlags.Value, false);
+      if (symbol) {
+        const callable = checker.getTypeOfSymbolAtLocation(symbol, file).getCallSignatures()[0];
+        const parameter = callable?.parameters[0];
+        if (parameter) {
+          const type = checker.getTypeOfSymbolAtLocation(parameter, file);
+          if (type.getProperties().length) return typeSchema(type, file, true);
+        }
+      }
+      const fields = node.attrs.flatMap((attr) => attr.kind !== "attribute" ? [] : [{ name: attr.name, optional: false, type: attr.value.type === "string" ? "string" : attr.value.type === "bool" ? "boolean" : inferExpression(attr.value.code) }]);
+      return { name: tagOf(node), origin: "inferred", fields };
+    }, visit2 = function(value, active, bindings = /* @__PURE__ */ new Map()) {
+      if (!value || typeof value !== "object") return;
+      if (Array.isArray(value)) {
+        value.forEach((child) => visit2(child, active, bindings));
+        return;
+      }
+      const node = value;
+      if (node.kind === "element") {
+        const element = value;
+        const kind = containerKind(element);
+        if (kind) {
+          const name = element.tag + (element.id ? "#" + element.id : "") + element.classes.map((name2) => "." + name2).join("");
+          active = { id: `btsx:${input.file}:${element.lineNo}`, file: input.file, line: element.lineNo, name, kind, source: "markup", itemType: { name: "Unknown", origin: "inferred", fields: [] }, items: [], editable: false, bindings: [], consumers: [], dataSources: [] };
+          collections.push(active);
+        }
+        if (active) {
+          for (const name of ["items", "tabs", "links"]) {
+            const attr = attribute(element, name);
+            if (attr?.kind === "attribute" && attr.value.type === "expr") {
+              const binding = attr.value.code.match(/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*/)?.[0];
+              if (binding) references.push({ collection: active, binding: bindings.get(binding.split(".")[0]) ?? binding, input });
+            }
+          }
+          const tag = tagOf(element);
+          const isTab = active.kind === "tabs" && ["button", "a", "Link"].includes(tag) || attrText(element, "role") === "tab" || /^(?:Tabs?Trigger|Tabs?\.Trigger)$/.test(tag);
+          if (isTab || element.tag === "a" || tag === "Link" || /(?:Nav|Menu|Sidebar)Item$/.test(tag) || (["menuitem", "button"].includes(attrText(element, "role") ?? "") || element.tag === "button") && active.kind === "navigation") {
+            const destination = attrText(element, "href") ?? attrText(element, "to");
+            const label = labelOf(element) || attrText(element, "aria-label") || attrText(element, "label") || tag;
+            active.items.push({ label, component: tag, line: element.lineNo, kind: isTab ? "tab" : destination ? itemKind(destination) : attribute(element, "onClick") ? "action" : "unknown", itemType: schemaOfControl2(element), ...destination ? { destination } : {}, ...attrText(element, "value") ? { value: attrText(element, "value") } : {} });
+          }
+        }
+      }
+      if (node.kind === "each") {
+        const iterable = String(node.iterable);
+        const rootBinding = iterable.match(/^[A-Za-z_$][\w$]*/)?.[0];
+        if (rootBinding) {
+          const binding = bindings.get(rootBinding) ?? iterable;
+          if (active) references.push({ collection: active, binding, input });
+          bindings = new Map(bindings);
+          bindings.set(String(node.itemName), binding);
+        }
+      }
+      for (const key of ["children", "branches", "declarations", "emptyChildren"]) visit2(node[key], active, bindings);
+    };
+    var schemaOfControl = schemaOfControl2, visit = visit2;
+    const file = program.getSourceFile(input.virtual);
+    const aliases = /* @__PURE__ */ new Map();
+    for (const statement of file.statements) if (ts2.isImportDeclaration(statement) && statement.importClause?.namedBindings && ts2.isNamedImports(statement.importClause.namedBindings)) {
+      for (const binding of statement.importClause.namedBindings.elements) aliases.set(binding.name.text, (binding.propertyName ?? binding.name).text);
+    }
+    const tagOf = (node) => aliases.get(node.tag) ?? node.tag;
+    const containerKind = (node) => attrText(node, "role") === "tablist" || /^(?:Tabs?|TabGroup|Tabs?Root|Tabs?List|Tabs?\.List)$/.test(tagOf(node)) ? "tabs" : node.tag === "nav" || ["navigation", "menu"].includes(attrText(node, "role") ?? "") || /^(?:Nav|Navigation|NavigationMenu|NavMenu|SidebarNav|MenuList)$/.test(tagOf(node)) ? "navigation" : void 0;
+    visit2(input.document);
+  }
+  const definitions = [];
+  const usedDeclarations = /* @__PURE__ */ new Set();
+  for (const reference of references) {
+    const file = program.getSourceFile(reference.input.virtual);
+    let symbol = checker.resolveName(reference.binding.split(".")[0], file, ts2.SymbolFlags.Value, false);
+    if (symbol?.flags && symbol.flags & ts2.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
+    if (symbol?.valueDeclaration) usedDeclarations.add(symbol.valueDeclaration);
+  }
+  for (const input of inputs) {
+    let visit2 = function(node) {
+      if (ts2.isVariableDeclaration(node) && ts2.isIdentifier(node.name) && node.initializer) {
+        const array = unbox(node.initializer);
+        const name = node.name.text;
+        const used = usedDeclarations.has(node) || references.some((reference) => reference.input.file === input.file && reference.binding.split(".")[0] === name);
+        if (!ts2.isArrayLiteralExpression(array)) {
+          const type = checker.getIndexTypeOfType(checker.getTypeAtLocation(node), ts2.IndexKind.Number);
+          if (type && (used || /nav|menu|links|tabs|panels/i.test(name) || type.getProperty("href") || type.getProperty("to"))) {
+            const collection = { id: `ts:${input.file}:${name}:${lineOf(input, node)}`, file: input.file, line: lineOf(input, node), name, kind: /tabs|panels/i.test(name) ? "tabs" : "navigation", source: "data", itemType: typeSchema(type, node, !!node.type), items: [], editable: false, reason: "Items are computed at runtime. The declared contract is available; values are not executed during scanning.", array: name, bindings: [], consumers: [], dataSources: [] };
+            collections.push(collection);
+            definitions.push({ declaration: node, collection, input });
+          }
+        }
+        if (ts2.isArrayLiteralExpression(array)) {
+          const objects = array.elements.filter(ts2.isObjectLiteralExpression);
+          const arrayType = elementType(array);
+          const links = !!(arrayType?.getProperty("href") || arrayType?.getProperty("to")) || objects.some((object) => field(object, "href") || field(object, "to") || field(object, "items"));
+          const hint = /nav|menu|links|tabs|panels/i.test(name);
+          if (links || hint || used) {
+            const kind = /tabs|panels/i.test(name) && !links ? "tabs" : "navigation";
+            const groups = objects.filter((object) => field(object, "items"));
+            const arrays = groups.length ? groups.flatMap((group) => {
+              const items = field(group, "items");
+              const label = textOf(field(group, "title")) ?? textOf(field(group, "label"));
+              return items && ts2.isArrayLiteralExpression(unbox(items)) && label ? [{ array: unbox(items), group: label }] : [];
+            }) : [{ array }];
+            for (const entry of arrays) {
+              const declared = declaredType(entry.array);
+              const context = elementType(entry.array);
+              const itemType = context ? typeSchema(context, entry.array, declared) : { name: "Unknown", origin: "inferred", fields: [] };
+              const statement = node.parent.parent;
+              const exported = ts2.isVariableStatement(statement) && !!statement.modifiers?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword);
+              const linkShape = !!(context?.getProperty("href") || context?.getProperty("to")) || entry.array.elements.some((item) => ts2.isObjectLiteralExpression(item) && (field(item, "href") || field(item, "to")));
+              const editable = kind === "navigation" && linkShape && exported && !input.file.endsWith(".btsx") && entry.array.elements.every(ts2.isObjectLiteralExpression) && (!groups.length || groups.length === array.elements.length);
+              const id = `ts:${input.file}:${name}${entry.group ? ":" + entry.group : ""}${exported ? "" : ":" + lineOf(input, node)}`;
+              const collection = { id, file: input.file, line: lineOf(input, node), name: name + (entry.group ? " / " + entry.group : ""), kind, source: "data", itemType, items: [], editable, ...editable ? {} : { reason: kind === "tabs" ? "Tab item types and values are available for inspection." : "This data is local, computed, or contains spreads; inspect it before editing." }, array: name, ...entry.group ? { group: entry.group } : {}, bindings: [], consumers: [], dataSources: [] };
+              for (const item of entry.array.elements) {
+                if (ts2.isObjectLiteralExpression(item)) {
+                  const destination = textOf(field(item, "href")) ?? textOf(field(item, "to"));
+                  const label = textOf(field(item, "label")) ?? textOf(field(item, "title")) ?? textOf(field(item, "id")) ?? textOf(field(item, "value")) ?? "Unnamed item";
+                  collection.items.push({ label, line: lineOf(input, item), kind: kind === "tabs" ? "tab" : destination ? itemKind(destination) : ["onClick", "onSelect", "action"].some((name2) => field(item, name2)) ? "action" : "unknown", itemType: typeSchema(narrowedType(item, context), item, declared), ...destination ? { destination } : {}, ...textOf(field(item, "value")) ?? textOf(field(item, "id")) ? { value: textOf(field(item, "value")) ?? textOf(field(item, "id")) } : {} });
+                } else {
+                  const primitive = textOf(item);
+                  collection.items.push({ label: primitive ?? item.getText(), line: lineOf(input, item), kind: kind === "tabs" ? "tab" : "unknown", itemType: typeSchema(checker.getTypeAtLocation(item), item, false), ...primitive ? { value: primitive } : {} });
+                }
+              }
+              definitions.push({ declaration: node, collection, input });
+              collections.push(collection);
+            }
+          }
+        }
+      }
+      ts2.forEachChild(node, visit2);
+    };
+    var visit = visit2;
+    const file = program.getSourceFile(input.virtual);
+    if (!file) continue;
+    visit2(file);
+  }
+  for (const reference of references) {
+    const file = program.getSourceFile(reference.input.virtual);
+    const rootName = reference.binding.split(".")[0];
+    let symbol = checker.resolveName(rootName, file, ts2.SymbolFlags.Value, false);
+    if (symbol && symbol.flags & ts2.SymbolFlags.Alias) {
+      try {
+        symbol = checker.getAliasedSymbol(symbol);
+      } catch {
+        symbol = void 0;
+      }
+    }
+    const matches = definitions.filter((definition) => symbol?.valueDeclaration === definition.declaration || definition.input.file === reference.input.file && definition.declaration.name.getText() === rootName);
+    if (!reference.collection.bindings.includes(reference.binding)) reference.collection.bindings.push(reference.binding);
+    if (!matches.length) {
+      let at = file;
+      if (!symbol) {
+        let visit2 = function(node) {
+          if ((ts2.isVariableDeclaration(node) || ts2.isBindingElement(node) || ts2.isParameter(node)) && ts2.isIdentifier(node.name) && node.name.text === rootName) local.push(node.name);
+          ts2.forEachChild(node, visit2);
+        };
+        var visit = visit2;
+        const local = [];
+        visit2(file);
+        at = local[0] ?? file;
+        symbol = checker.getSymbolAtLocation(at);
+      }
+      let type = symbol && checker.getTypeOfSymbolAtLocation(symbol, at);
+      for (const part of reference.binding.split(".").slice(1)) {
+        const property2 = type?.getProperty(part);
+        type = property2 && checker.getTypeOfSymbolAtLocation(property2, at);
+      }
+      const item = type && checker.getIndexTypeOfType(type, ts2.IndexKind.Number);
+      if (item) {
+        reference.collection.itemType = typeSchema(item, at, true);
+        reference.collection.reason = "The item contract is resolved from the binding; values are supplied at runtime.";
+      }
+    }
+    for (const { collection } of matches) {
+      const consumer = { file: reference.collection.file, line: reference.collection.line, name: reference.collection.name };
+      if (!collection.consumers.some((item) => item.file === consumer.file && item.line === consumer.line)) collection.consumers.push(consumer);
+      if (!reference.collection.dataSources.includes(collection.id)) reference.collection.dataSources.push(collection.id);
+      if (!reference.collection.bindings.includes(reference.binding)) reference.collection.bindings.push(reference.binding);
+    }
+  }
+  for (const collection of collections.filter((collection2) => collection2.source === "data")) {
+    if (collection.consumers.length && collection.consumers.every((consumer) => collections.some((rendered) => rendered.source === "markup" && rendered.file === consumer.file && rendered.line === consumer.line && rendered.kind === "tabs"))) {
+      collection.kind = "tabs";
+      collection.editable = false;
+      collection.items.forEach((item) => {
+        item.kind = "tab";
+      });
+      if (collection.reason === "This data is local, computed, or contains spreads; inspect it before editing.") collection.reason = "Tab item types and values are available for inspection.";
+    }
+  }
+  for (const collection of collections.filter((collection2) => collection2.source === "markup")) {
+    const data = collections.filter((data2) => collection.dataSources.includes(data2.id));
+    if (data.length) {
+      collection.items = data.flatMap((data2) => data2.items.map((item) => collection.kind === "tabs" ? { ...item, kind: "tab" } : item));
+      collection.itemType = data.length === 1 ? data[0].itemType : { name: [...new Set(data.map((data2) => data2.itemType.name))].join(" | "), origin: data.every((data2) => data2.itemType.origin === "declared") ? "declared" : "inferred", fields: [], variants: data.map((data2) => data2.itemType) };
+      collection.reason = `Renders shared data in ${[...new Set(data.map((data2) => data2.file))].join(", ")}.`;
+    } else {
+      const types = [...new Map(collection.items.map((item) => [JSON.stringify(item.itemType), item.itemType])).values()];
+      if (!collection.reason) collection.itemType = types.length > 1 ? { name: types.map((type) => type.name).join(" | "), origin: types.every((type) => type.origin === "declared") ? "declared" : "inferred", fields: [], variants: types } : types[0] ?? collection.itemType;
+      const targetNode = findElement(inputDocument(collection.file), collection.line);
+      collection.editable = collection.kind === "navigation" && !sources.find((input) => input.file === collection.file)?.page && !!targetNode && targetNode.tag === "nav" && targetNode.children.every((child) => child.kind === "element" && ["a", "Link"].includes(child.tag));
+      if (!collection.editable && !collection.reason) collection.reason = collection.kind === "tabs" ? "Tab controls are detected for inspection; they are not page navigation targets." : "This menu uses a custom layout or belongs to a page.";
+    }
+  }
+  function inputDocument(file) {
+    return inputs.find((input) => input.file === file)?.document;
+  }
+  return collections.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.name.localeCompare(b.name));
+}
+function labelOf(node) {
+  return [(node.inlineSpans ?? []).map((span) => span.type === "literal" ? span.text : `#{${span.code}}`).join(""), ...node.children.flatMap((child) => child.kind === "element" ? [labelOf(child)] : child.kind === "text" ? [child.spans.map((span) => span.type === "literal" ? span.text : `#{${span.code}}`).join("")] : [])].filter(Boolean).join(" ");
+}
+function findElement(value, line) {
+  if (!value || typeof value !== "object") return;
+  if (Array.isArray(value)) return value.map((child) => findElement(child, line)).find(Boolean);
+  const node = value;
+  if (node.kind === "element" && node.lineNo === line) return value;
+  for (const key of ["children", "branches", "declarations"]) {
+    const found = findElement(node[key], line);
+    if (found) return found;
+  }
+}
+
+// server/project.ts
+var IGNORED = /* @__PURE__ */ new Set(["node_modules", ".git", ".beast", "dist", "build", "coverage", ".next"]);
+var BuilderError = class extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+};
+var posix = (path) => path.split(sep).join("/");
+var inside = (root, path) => {
+  const rel = relative2(root, path);
+  return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+};
+var BuilderProject = class {
+  constructor(root, options = {}) {
+    this.options = options;
+    this.root = resolve2(root);
+    this.pagesDir = options.pagesDir ?? "src/pages";
+    this.routerFile = options.routerFile ?? "src/router.ts";
+    this.include = [.../* @__PURE__ */ new Set([...options.include ?? ["src"], this.pagesDir])];
+    for (const path of [...this.include, this.routerFile, ...options.navigation ? [options.navigation.file] : []]) {
+      if (isAbsolute(path) || !inside(this.root, resolve2(this.root, path))) throw new BuilderError("Scan and page directories must be inside the project.");
+    }
+    if (!this.routerFile.endsWith(".ts")) throw new BuilderError("routerFile must be a TypeScript file.");
+    if (options.navigation && !/\.(?:tsx?|btsx)$/.test(options.navigation.file)) throw new BuilderError("navigation.file must be .ts, .tsx, or .btsx.");
+  }
+  root;
+  include;
+  pagesDir;
+  routerFile;
+  compiler;
+  mutation = Promise.resolve();
+  creations = /* @__PURE__ */ new Map();
+  /** Check existing ancestors too, so a configured directory cannot escape through a symlink. */
+  async safe(path) {
+    const canonicalRoot = await realpath(this.root);
+    let current = path;
+    for (; ; ) {
+      try {
+        if (!inside(canonicalRoot, await realpath(current))) throw new BuilderError("Path resolves outside the project.", 403);
+        return;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+        current = dirname2(current);
+      }
+    }
+  }
+  async scan() {
+    const files = [];
+    const warnings = [];
+    let navigationTargets = [];
+    const sources = /* @__PURE__ */ new Map();
+    const visited = /* @__PURE__ */ new Set();
+    const walk = async (directory) => {
+      if (visited.has(directory)) return;
+      visited.add(directory);
+      try {
+        await this.safe(directory);
+        const entries = await readdir(directory, { withFileTypes: true });
+        for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+          const path = resolve2(directory, entry.name);
+          if (entry.isSymbolicLink()) continue;
+          if (entry.isDirectory() && !IGNORED.has(entry.name) && !entry.name.startsWith(".")) await walk(path);
+          else if (entry.isFile() && entry.name.endsWith(".btsx")) {
+            if (sources.size >= 5e3) throw new BuilderError("Scan limited to 5,000 files. Narrow the include directories.");
+            const source = await readFile(path, "utf8");
+            const name = componentNameFromPath(path);
+            let components = [name];
+            let error = null;
+            try {
+              const result = compileBeastResult3(source, { filename: path });
+              components = [name, ...result.ast.declarations.flatMap((d) => d.kind === "component" ? [d.name] : [])];
+            } catch (cause) {
+              error = cause instanceof Error ? cause.message : String(cause);
+            }
+            const filePath = posix(relative2(this.root, path));
+            files.push({ path: filePath, name, kind: inside(resolve2(this.root, this.pagesDir), path) || /(?:^|\/)(pages|routes)\//.test(filePath) || /Page$/.test(name) ? "page" : "component", lines: source.split("\n").length, components, error });
+            sources.set(filePath, { file: filePath, source, page: files.at(-1).kind === "page" });
+          } else if (entry.isFile() && /\.tsx?$/.test(entry.name)) {
+            if (sources.size >= 5e3) throw new BuilderError("Scan limited to 5,000 files. Narrow the include directories.");
+            const file = posix(relative2(this.root, path));
+            sources.set(file, { file, source: await readFile(path, "utf8"), page: false });
+          }
+        }
+      } catch (cause) {
+        if (cause.code !== "ENOENT") warnings.push(`${posix(relative2(this.root, directory))}: ${cause instanceof Error ? cause.message : String(cause)}`);
+      }
+    };
+    for (const directory of this.include) await walk(resolve2(this.root, directory));
+    if (this.options.navigation) {
+      try {
+        const file = posix(relative2(this.root, resolve2(this.root, this.options.navigation.file)));
+        await this.safe(resolve2(this.root, file));
+        const source = await readFile(resolve2(this.root, file), "utf8");
+        sources.set(file, { file, source, page: false });
+        navigationTargets.push(...discoverNavigation(source, file, this.options.navigation));
+      } catch (cause) {
+        warnings.push(cause instanceof Error ? cause.message : String(cause));
+      }
+    }
+    const collections = discoverCollections(this.root, [...sources.values()]);
+    if (this.options.navigation) {
+      navigationTargets = navigationTargets.filter((target) => collections.find((collection) => collection.id === target.id)?.kind !== "tabs").map((target) => ({ ...target, itemType: collections.find((collection) => collection.id === target.id)?.itemType }));
+    } else {
+      navigationTargets = collections.filter((collection) => collection.editable && collection.kind === "navigation").map((collection) => ({ id: collection.id, file: collection.file, label: `${collection.file} \xB7 ${collection.name}`, array: collection.array, group: collection.group, itemType: collection.itemType }));
+    }
+    return { collections, name: basename(this.root), files: files.sort((a, b) => a.path.localeCompare(b.path)), scannedAt: (/* @__PURE__ */ new Date()).toISOString(), warnings, navigationTargets };
+  }
+  async source(path) {
+    if (typeof path !== "string" || !path.endsWith(".btsx") || isAbsolute(path)) throw new BuilderError("Expected a project-relative .btsx path.");
+    const target = resolve2(this.root, path);
+    if (!this.include.some((dir) => inside(resolve2(this.root, dir), target))) throw new BuilderError("File is outside the scan directories.", 403);
+    await this.safe(target);
+    return readFile(target, "utf8");
+  }
+  async preview(draft) {
+    if (typeof draft.name !== "string" || !/^[A-Z][A-Za-z0-9]{0,79}$/.test(draft.name)) throw new BuilderError("Use a PascalCase page name, such as PricingPage.");
+    if (typeof draft.source !== "string" || !draft.source.trim() || Buffer.byteLength(draft.source) > 6e4) throw new BuilderError("Page source must contain between 1 and 60,000 bytes.");
+    const path = posix(relative2(this.root, resolve2(this.root, this.pagesDir, `${draft.name}.btsx`)));
+    const target = resolve2(this.root, path);
+    await this.safe(target);
+    try {
+      await lstat(target);
+      throw new BuilderError(`${path} already exists. Choose another name.`, 409);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const source = draft.source.replace(/\r\n/g, "\n").trimEnd() + "\n";
+    try {
+      const result = compileBeastResult3(source, { filename: target, componentName: draft.name });
+      this.compiler ??= createOctaneCompiler({ root: this.root, environment: "client", hmr: false, dev: true });
+      this.compiler.transform(result.code, target.replace(/\.btsx$/, ".tsrx"), { environment: "client", dev: true });
+    } catch (cause) {
+      throw new BuilderError(cause instanceof Error ? cause.message : String(cause), 422);
+    }
+    const derived = draft.name.replace(/Page$/, "").replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+    const routePath = draft.routePath ?? "/" + (derived || "page");
+    if (typeof routePath !== "string" || !/^\/[a-z0-9]+(?:[-/][a-z0-9]+)*$/.test(routePath) || routePath.length > 200) throw new BuilderError("Use a static URL such as /about or /company/about.");
+    const navLabel = draft.navLabel ?? draft.name.replace(/Page$/, "").replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+    if (typeof navLabel !== "string" || !navLabel.trim() || navLabel.length > 100 || /[\r\n\x00-\x1f]/.test(navLabel)) throw new BuilderError("Use a navigation label between 1 and 100 characters.");
+    const routerPath = posix(relative2(this.root, resolve2(this.root, this.routerFile)));
+    await this.safe(resolve2(this.root, routerPath));
+    let routerSource;
+    try {
+      routerSource = await readFile(resolve2(this.root, routerPath), "utf8");
+    } catch (cause) {
+      if (cause.code === "ENOENT") throw new BuilderError(`${routerPath} is missing. Set up @octanejs/tanstack-router before adding pages.`, 422);
+      throw cause;
+    }
+    const routerAfter = registerRoute(routerSource, routerPath, path, draft.name, routePath);
+    const { navigationTargets } = await this.scan();
+    const navigation = draft.navigationTarget ? navigationTargets.find((target2) => target2.id === draft.navigationTarget) : navigationTargets.length === 1 ? navigationTargets[0] : void 0;
+    if (!navigation) throw new BuilderError(navigationTargets.length ? "Choose a navigation menu for the new link." : "No editable navigation found. Configure navigation.file with a BTSX nav or a TypeScript menu array.", 422);
+    await this.safe(resolve2(this.root, navigation.file));
+    const navSource = await readFile(resolve2(this.root, navigation.file), "utf8");
+    const navAfter = addNavigation(navSource, navigation, routePath, navLabel.trim(), this.options.navigation);
+    if (navigation.file.endsWith(".btsx")) {
+      const result = compileBeastResult3(navAfter, { filename: navigation.file });
+      this.compiler.transform(result.code, navigation.file.replace(/\.btsx$/, ".tsrx"), { environment: "client", dev: true });
+    }
+    if ((/* @__PURE__ */ new Set([path, routerPath, navigation.file])).size !== 3) throw new BuilderError("Page, router, and navigation must use separate files.");
+    const files = [
+      { path, action: "create", before: null, source },
+      { path: routerPath, action: "edit", before: routerSource, source: routerAfter },
+      { path: navigation.file, action: "edit", before: navSource, source: navAfter }
+    ];
+    const hash = createHash("sha256").update(JSON.stringify({ routePath, navLabel: navLabel.trim(), files })).digest("hex");
+    return { path, source, hash, routePath, navLabel: navLabel.trim(), files };
+  }
+  async create(draft, hash) {
+    if (typeof hash !== "string" || !/^[a-f0-9]{64}$/.test(hash)) throw new BuilderError("Review the page before saving.");
+    const operation = this.mutation.then(async () => {
+      const preview = await this.preview(draft);
+      if (hash !== preview.hash) throw new BuilderError("The draft, router, or navigation changed. Review again before saving.", 409);
+      for (const file of preview.files) {
+        const target = resolve2(this.root, file.path);
+        await this.safe(target);
+        if (file.before !== null && await readFile(target, "utf8") !== file.before) throw new BuilderError(`${file.path} changed. Review again.`, 409);
+      }
+      const written = [];
+      const staged = [];
+      try {
+        for (const file of preview.files) {
+          const target = resolve2(this.root, file.path);
+          await mkdir(dirname2(target), { recursive: true });
+          await this.safe(target);
+          if (file.before !== null && (await lstat(target)).isSymbolicLink()) throw new BuilderError(`${file.path} is a symlink. Configure a regular source file.`, 403);
+          const mode = file.before === null ? 438 : (await stat(target)).mode & 511;
+          const temporary = resolve2(dirname2(target), `.beast-page-builder-${randomUUID()}.tmp`);
+          staged.push({ file, temporary, mode });
+          await writeFile(temporary, file.source, { flag: "wx", mode });
+          if (file.before !== null) await chmod(temporary, mode);
+        }
+        for (const { file, temporary } of staged) {
+          const target = resolve2(this.root, file.path);
+          await this.safe(target);
+          if (file.before !== null && await readFile(target, "utf8") !== file.before) throw new BuilderError(`${file.path} changed during save. Review again.`, 409);
+          if (file.before === null) await link(temporary, target);
+          else await rename(temporary, target);
+          written.push(file);
+        }
+      } catch (cause) {
+        const failures = [];
+        for (const file of written.reverse()) {
+          const target = resolve2(this.root, file.path);
+          try {
+            await this.safe(target);
+            const current = await readFile(target, "utf8");
+            if (current !== file.source) {
+              failures.push(file.path);
+              continue;
+            }
+            if (file.before === null) await unlink(target);
+            else {
+              const stage = staged.find((item) => item.file === file);
+              await writeFile(stage.temporary, file.before, { flag: "wx", mode: stage.mode });
+              await rename(stage.temporary, target);
+            }
+          } catch {
+            failures.push(file.path);
+          }
+        }
+        if (failures.length) throw new BuilderError(`Save failed; could not restore ${failures.join(", ")}. Inspect these files before retrying.`, 500);
+        if (cause.code === "EEXIST") throw new BuilderError("A file with this name now exists. Review again.", 409);
+        throw cause;
+      } finally {
+        await Promise.all(staged.map((item) => unlink(item.temporary).catch(() => {
+        })));
+      }
+      return preview;
+    });
+    this.mutation = operation.then(() => {
+    }, () => {
+    });
+    this.creations.set(hash, operation);
+    if (this.creations.size > 20) this.creations.delete(this.creations.keys().next().value);
+    return operation;
+  }
+  /** A reload can interrupt the browser response while the file transaction finishes. */
+  async creation(hash) {
+    const result = this.creations.get(hash);
+    if (!result) throw new BuilderError("Save result is unavailable. Inspect the project before retrying.", 404);
+    return result;
+  }
+};
+
+// server/server.ts
+var CLIENT_ENTRY = fileURLToPath(new URL("./client.js", import.meta.url));
+var SHORTCUT = /^(?:Mod|Meta|Ctrl)(?:\+Shift)?\+[A-Za-z]$/;
+function clientConfig(options) {
+  const shortcut = options.shortcut ?? "Mod+B";
+  if (!SHORTCUT.test(shortcut)) throw new BuilderError("Shortcut must be Mod+B, Meta+B, Ctrl+B, or include +Shift.");
+  if (options.position && !["center", "bottom-right"].includes(options.position)) throw new BuilderError("Unknown widget position.");
+  if (options.theme && !["light", "dark", "auto"].includes(options.theme)) throw new BuilderError("Unknown widget theme.");
+  const scanDuration = options.scanDuration ?? 1600;
+  if (!Number.isFinite(scanDuration) || scanDuration < 0 || scanDuration > 1e4) throw new BuilderError("scanDuration must be between 0 and 10,000 milliseconds.");
+  return { shortcut, position: options.position ?? "center", theme: options.theme ?? "light", scanDuration, launcher: options.launcher ?? true, pagesDir: options.pagesDir ?? "src/pages", routerFile: options.routerFile ?? "src/router.ts" };
+}
+function checkOrigin(req) {
+  if (req.headers["sec-fetch-site"] === "cross-site") throw new BuilderError("Cross-site requests are refused.", 403);
+  const origin = req.headers.origin;
+  if (origin) {
+    let host;
+    try {
+      host = new URL(origin).host;
+    } catch {
+      throw new BuilderError("Invalid origin.", 403);
+    }
+    if (host !== req.headers.host) throw new BuilderError("Request must come from the development page.", 403);
+  }
+}
+async function jsonBody(req) {
+  if (!req.headers["content-type"]?.startsWith("application/json")) throw new BuilderError("Expected application/json.", 415);
+  const chunks = [];
+  let length = 0;
+  for await (const chunk of req) {
+    length += Buffer.byteLength(chunk);
+    if (length > 65536) throw new BuilderError("Request is too large.", 413);
+    chunks.push(Buffer.from(chunk));
+  }
+  try {
+    const result = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (!result || typeof result !== "object" || Array.isArray(result)) throw new Error();
+    return result;
+  } catch {
+    throw new BuilderError("Invalid JSON body.");
+  }
+}
+function createBuilderServer(root, options = {}, basePath = "/") {
+  const config = clientConfig(options);
+  const project = new BuilderProject(root, options);
+  const middleware = (req, res, next) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const prefixedBase = basePath.replace(/\/$/, "") + BASE;
+    const routeBase = url.pathname.startsWith(prefixedBase + "/") ? prefixedBase : BASE;
+    if (!url.pathname.startsWith(routeBase + "/")) return next();
+    const send = (status, data) => {
+      res.writeHead(status, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+      res.end(JSON.stringify(data));
+    };
+    void (async () => {
+      checkOrigin(req);
+      const route = url.pathname.slice(routeBase.length);
+      if (req.method === "GET" && route === "/client.js") {
+        res.writeHead(200, { "Content-Type": "text/javascript; charset=utf-8", "Cache-Control": "no-store" });
+        res.end(await readFile2(CLIENT_ENTRY, "utf8"));
+      } else if (req.method === "GET" && route === "/config") send(200, config);
+      else if (req.method === "GET" && route === "/scan") send(200, await project.scan());
+      else if (req.method === "GET" && route === "/creation") send(200, await project.creation(url.searchParams.get("hash") ?? ""));
+      else if (req.method === "GET" && route === "/source") send(200, { source: await project.source(url.searchParams.get("path") ?? "") });
+      else if (req.method === "POST" && (route === "/preview" || route === "/create")) {
+        const body = await jsonBody(req);
+        const draft = { name: body.name, source: body.source, routePath: body.routePath, navLabel: body.navLabel, navigationTarget: body.navigationTarget };
+        send(route === "/create" ? 201 : 200, route === "/create" ? await project.create(draft, body.hash) : await project.preview(draft));
+      } else send(404, { error: "Unknown page-builder endpoint." });
+    })().catch((error) => {
+      const code = error.code;
+      send(error instanceof BuilderError ? error.status : code === "ENOENT" ? 404 : 500, { error: error instanceof Error ? error.message : String(error) });
+    });
+  };
+  return { middleware, project, clientEntry: CLIENT_ENTRY };
+}
+
+// rsbuild.ts
+function beastPageBuilder(options = {}) {
+  return {
+    name: "beast:page-builder",
+    apply: "serve",
+    setup(api) {
+      api.modifyEnvironmentConfig((config, { mergeEnvironmentConfig }) => {
+        if (config.output.target !== "web") return config;
+        return mergeEnvironmentConfig(config, { source: { preEntry: [CLIENT_ENTRY] } });
+      });
+      api.onBeforeStartDevServer(({ server }) => {
+        server.middlewares.use(createBuilderServer(api.context.rootPath, options).middleware);
+      });
+    }
+  };
+}
+export {
+  beastPageBuilder
+};