@absolutejs/absolute 0.19.0-beta.1038 → 0.19.0-beta.1039

package/dist/cli/index.js

@@ -172046,6 +172046,1151 @@ var init_mem = __esm(() => {
   HEADERS = ["NAME", "SOURCE", "PORT", "RSS", "% SYS"];
 });
 
+// src/cli/config/schema/fromType.ts
+var import_typescript3, cache;
+var init_fromType = __esm(() => {
+  import_typescript3 = __toESM(require_typescript(), 1);
+  cache = new Map;
+});
+
+// src/cli/config/absolute/resolveAbsoluteConfig.ts
+import { existsSync as existsSync13, readFileSync as readFileSync15 } from "fs";
+import { resolve as resolve11 } from "path";
+var import_typescript4, CONFIG_CANDIDATES2, RUNTIME_FIELDS, findConfigPath2 = (cwd, override) => {
+  if (override) {
+    const resolved = resolve11(cwd, override);
+    return existsSync13(resolved) ? resolved : null;
+  }
+  for (const name of CONFIG_CANDIDATES2) {
+    const candidate = resolve11(cwd, name);
+    if (existsSync13(candidate))
+      return candidate;
+  }
+  return null;
+};
+var init_resolveAbsoluteConfig = __esm(() => {
+  init_fromType();
+  import_typescript4 = __toESM(require_typescript(), 1);
+  CONFIG_CANDIDATES2 = [
+    "absolute.config.ts",
+    "absolute.config.js",
+    "absolute.config.mjs"
+  ];
+  RUNTIME_FIELDS = new Set([
+    "cwd",
+    "config",
+    "entry",
+    "mode",
+    "incrementalFiles"
+  ]);
+});
+
+// src/cli/generate/frameworkKey.ts
+var FRAMEWORK_KEYS2, isFrameworkKey = (value) => FRAMEWORK_KEYS2.some((key) => key === value);
+var init_frameworkKey = __esm(() => {
+  FRAMEWORK_KEYS2 = [
+    "angular",
+    "html",
+    "htmx",
+    "react",
+    "svelte",
+    "vue"
+  ];
+});
+
+// src/cli/generate/frameworks.ts
+var ABS = "@absolutejs/absolute", reactDef, svelteDef, vueDef, angularDef, htmlDef, htmxDef, frameworks2;
+var init_frameworks = __esm(() => {
+  reactDef = {
+    configDirKey: "reactDirectory",
+    kind: "manifest",
+    label: "React",
+    pageImportExtension: null,
+    componentFile: ({ pascal }) => `${pascal}.tsx`,
+    pageFile: ({ pascal }) => `${pascal}.tsx`,
+    routeExpression: (ctx) => `.get('${ctx.route}', () => handleReactPageRequest({ Page: ${ctx.pascal}, index: asset(manifest, '${ctx.indexKey}'), props: { cssPath: asset(manifest, '${ctx.cssAssetKey}') } }))`,
+    routeImports: (ctx) => [
+      { kind: "named", module: ABS, name: "asset" },
+      {
+        kind: "named",
+        module: `${ABS}/react`,
+        name: "handleReactPageRequest"
+      },
+      { kind: "named", module: ctx.pageSpecifier, name: ctx.pascal }
+    ]
+  };
+  svelteDef = {
+    configDirKey: "svelteDirectory",
+    kind: "manifest",
+    label: "Svelte",
+    pageImportExtension: ".svelte",
+    componentFile: ({ pascal }) => `${pascal}.svelte`,
+    pageFile: ({ pascal }) => `${pascal}.svelte`,
+    routeExpression: (ctx) => `.get('${ctx.route}', () => handleSveltePageRequest<typeof ${ctx.pascal}>({ indexPath: asset(manifest, '${ctx.indexKey}'), pagePath: asset(manifest, '${ctx.manifestKey}'), props: { cssPath: asset(manifest, '${ctx.cssAssetKey}') } }))`,
+    routeImports: (ctx) => [
+      { kind: "named", module: ABS, name: "asset" },
+      {
+        kind: "named",
+        module: `${ABS}/svelte`,
+        name: "handleSveltePageRequest"
+      },
+      { kind: "typeDefault", local: ctx.pascal, module: ctx.pageSpecifier }
+    ]
+  };
+  vueDef = {
+    configDirKey: "vueDirectory",
+    kind: "manifest",
+    label: "Vue",
+    pageImportExtension: ".vue",
+    componentFile: ({ pascal }) => `${pascal}.vue`,
+    pageFile: ({ pascal }) => `${pascal}.vue`,
+    routeExpression: (ctx) => `.get('${ctx.route}', () => handleVuePageRequest<typeof ${ctx.pascal}>({ headTag: generateHeadElement({ cssPath: asset(manifest, '${ctx.cssAssetKey}'), title: '${ctx.title}' }), indexPath: asset(manifest, '${ctx.indexKey}'), pagePath: asset(manifest, '${ctx.manifestKey}'), props: {} }))`,
+    routeImports: (ctx) => [
+      { kind: "named", module: ABS, name: "asset" },
+      { kind: "named", module: ABS, name: "generateHeadElement" },
+      { kind: "named", module: `${ABS}/vue`, name: "handleVuePageRequest" },
+      { kind: "typeDefault", local: ctx.pascal, module: ctx.pageSpecifier }
+    ]
+  };
+  angularDef = {
+    configDirKey: "angularDirectory",
+    kind: "manifest",
+    label: "Angular",
+    pageImportExtension: null,
+    componentFile: ({ kebab }) => `${kebab}.component.ts`,
+    pageFile: ({ kebab }) => `${kebab}.ts`,
+    routeExpression: (ctx) => `.get('${ctx.route}', ({ request }) => handleAngularPageRequest<${ctx.pascal}Page.Context>({ headTag: generateHeadElement({ cssPath: asset(manifest, '${ctx.cssAssetKey}'), title: '${ctx.title}' }), indexPath: asset(manifest, '${ctx.indexKey}'), pagePath: asset(manifest, '${ctx.manifestKey}'), request, requestContext: {} }))`,
+    routeImports: (ctx) => [
+      { kind: "named", module: ABS, name: "asset" },
+      { kind: "named", module: ABS, name: "generateHeadElement" },
+      {
+        kind: "named",
+        module: `${ABS}/angular`,
+        name: "handleAngularPageRequest"
+      },
+      {
+        kind: "typeNamespace",
+        local: `${ctx.pascal}Page`,
+        module: ctx.pageSpecifier
+      }
+    ]
+  };
+  htmlDef = {
+    configDirKey: "htmlDirectory",
+    kind: "static",
+    label: "HTML",
+    pageImportExtension: null,
+    componentFile: ({ pascal }) => `${pascal}.html`,
+    pageFile: ({ pascal }) => `${pascal}.html`,
+    routeExpression: (ctx) => `.get('${ctx.route}', () => handleHTMLPageRequest(asset(manifest, '${ctx.manifestKey}')))`,
+    routeImports: () => [
+      { kind: "named", module: ABS, name: "asset" },
+      { kind: "named", module: ABS, name: "handleHTMLPageRequest" }
+    ]
+  };
+  htmxDef = {
+    configDirKey: "htmxDirectory",
+    kind: "static",
+    label: "HTMX",
+    pageImportExtension: null,
+    componentFile: ({ pascal }) => `${pascal}.html`,
+    pageFile: ({ pascal }) => `${pascal}.html`,
+    routeExpression: (ctx) => `.get('${ctx.route}', () => handleHTMXPageRequest(asset(manifest, '${ctx.manifestKey}')))`,
+    routeImports: () => [
+      { kind: "named", module: ABS, name: "asset" },
+      { kind: "named", module: ABS, name: "handleHTMXPageRequest" }
+    ]
+  };
+  frameworks2 = {
+    angular: angularDef,
+    html: htmlDef,
+    htmx: htmxDef,
+    react: reactDef,
+    svelte: svelteDef,
+    vue: vueDef
+  };
+});
+
+// src/cli/generate/context.ts
+import { dirname as dirname4, isAbsolute, join as join14, relative as relative3, resolve as resolve12 } from "path";
+var asString = (value) => typeof value === "string" ? value : undefined, isRecord3 = (value) => typeof value === "object" && value !== null, resolveDir = (cwd, value) => isAbsolute(value) ? value : resolve12(cwd, value), resolveStylesDir = (cwd, config) => {
+  const styles = config.stylesConfig;
+  if (typeof styles === "string")
+    return resolveDir(cwd, styles);
+  if (isRecord3(styles)) {
+    const indexes = asString(styles.indexes);
+    if (indexes)
+      return resolveDir(cwd, indexes);
+  }
+  return resolve12(cwd, "src/frontend/styles/indexes");
+}, configuredFrameworks = (project) => FRAMEWORK_KEYS2.filter((key) => project.frameworkDirs[key] !== undefined), frontendRootFor = (project, framework) => {
+  const dir = project.frameworkDirs[framework];
+  return dir ? dirname4(dir) : resolve12(project.cwd, "src/frontend");
+}, resolveProject = async (cwd, configOverride) => {
+  const loaded = await loadConfig(configOverride);
+  const config = isRecord3(loaded) ? loaded : {};
+  const frameworkDirs = {};
+  for (const key of FRAMEWORK_KEYS2) {
+    const dir = asString(config[frameworks2[key].configDirKey]);
+    if (dir)
+      frameworkDirs[key] = resolveDir(cwd, dir);
+  }
+  const entry = asString(config.entry) ?? DEFAULT_SERVER_ENTRY;
+  return {
+    config,
+    configPath: findConfigPath2(cwd, configOverride),
+    cwd,
+    frameworkDirs,
+    serverEntry: resolveDir(cwd, entry),
+    stylesDir: resolveStylesDir(cwd, config)
+  };
+}, selectFramework = (project, explicit) => {
+  const configured = configuredFrameworks(project);
+  if (explicit !== undefined) {
+    if (!isFrameworkKey(explicit)) {
+      return {
+        message: `Unknown framework "${explicit}".`,
+        ok: false
+      };
+    }
+    if (!configured.includes(explicit)) {
+      return {
+        message: `Framework "${explicit}" is not configured. Add it with \`absolute add ${explicit}\`.`,
+        ok: false
+      };
+    }
+    return { framework: explicit, ok: true };
+  }
+  if (configured.length === 0) {
+    return {
+      message: "No frameworks are configured in absolute.config.ts.",
+      ok: false
+    };
+  }
+  const [only] = configured;
+  if (configured.length === 1 && only) {
+    return { framework: only, ok: true };
+  }
+  return {
+    message: `Multiple frameworks configured (${configured.join(", ")}). Pass --framework <name>.`,
+    ok: false
+  };
+}, sharedDirFor = (project, framework) => join14(frontendRootFor(project, framework), "shared"), toModuleSpecifier = (fromDir, toFileNoExt) => {
+  const rel = relative3(fromDir, toFileNoExt).split("\\").join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+};
+var init_context = __esm(() => {
+  init_loadConfig();
+  init_resolveAbsoluteConfig();
+  init_utils();
+  init_frameworkKey();
+  init_frameworks();
+});
+
+// src/cli/generate/naming.ts
+var tokenize = (raw) => raw.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).filter((token) => token.length > 0).map((token) => token.toLowerCase()), capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1), isValidName = (raw) => typeof raw === "string" && tokenize(raw).length > 0, toCamelCase = (raw) => {
+  const pascal = toPascalCase(raw);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}, toKebabCase = (raw) => tokenize(raw).join("-"), toPascalCase = (raw) => tokenize(raw).map(capitalize).join(""), toTitleCase = (raw) => tokenize(raw).map(capitalize).join(" ");
+
+// src/cli/generate/outcome.ts
+var emptyOutcome = () => ({
+  created: [],
+  manual: null,
+  notes: [],
+  route: null,
+  updated: []
+});
+
+// src/cli/generate/routeWiring.ts
+import { existsSync as existsSync14, readFileSync as readFileSync16, readdirSync as readdirSync4, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname5, join as join15 } from "path";
+var import_typescript5, DEFAULT_SEPARATOR = `
+		`, BOUNDARY_USE, applyEdits = (text, edits) => {
+  const ordered = [...edits].sort((first, second) => second.start - first.start);
+  let output = text;
+  for (const edit of ordered) {
+    output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+  }
+  return output;
+}, stripExtension = (path) => path.replace(/\.[^./\\]+$/, ""), parse2 = (path, text) => import_typescript5.default.createSourceFile(path, text, import_typescript5.default.ScriptTarget.Latest, true), findElysiaNew = (sourceFile) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (import_typescript5.default.isNewExpression(node) && import_typescript5.default.isIdentifier(node.expression) && node.expression.text === "Elysia") {
+      found = node;
+      return;
+    }
+    import_typescript5.default.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}, climbChain = (start2) => {
+  let top = start2;
+  while (import_typescript5.default.isPropertyAccessExpression(top.parent) && top.parent.expression === top && import_typescript5.default.isCallExpression(top.parent.parent) && top.parent.parent.expression === top.parent) {
+    top = top.parent.parent;
+  }
+  return top;
+}, collectCalls = (top) => {
+  const calls = [];
+  let node = top;
+  while (import_typescript5.default.isCallExpression(node) && import_typescript5.default.isPropertyAccessExpression(node.expression)) {
+    calls.push(node);
+    node = node.expression.expression;
+  }
+  return calls.reverse();
+}, methodName = (call) => import_typescript5.default.isPropertyAccessExpression(call.expression) ? call.expression.name.text : null, isBoundary = (call) => {
+  const name = methodName(call);
+  const [arg] = call.arguments;
+  if (name === "use" && arg && import_typescript5.default.isIdentifier(arg)) {
+    return BOUNDARY_USE.has(arg.text);
+  }
+  return name === "on" && arg !== undefined && import_typescript5.default.isStringLiteralLike(arg);
+}, receiverEnd = (call) => import_typescript5.default.isPropertyAccessExpression(call.expression) ? call.expression.expression.getEnd() : call.getEnd(), separatorBefore = (text, offset) => {
+  const match = text.slice(offset).match(/^(\s*\n[ \t]*)\./);
+  return match ? match[1] : DEFAULT_SEPARATOR;
+}, findRouteInsertion = (text, top) => {
+  const calls = collectCalls(top);
+  const boundary = calls.find(isBoundary);
+  if (boundary) {
+    const offset2 = receiverEnd(boundary);
+    return { offset: offset2, separator: separatorBefore(text, offset2) };
+  }
+  const last = calls[calls.length - 1];
+  const offset = last ? last.getEnd() : top.getEnd();
+  const sepProbe = last ? receiverEnd(last) : top.getEnd();
+  return { offset, separator: separatorBefore(text, sepProbe) };
+}, namedImportDecl = (sourceFile, module) => sourceFile.statements.find((statement) => import_typescript5.default.isImportDeclaration(statement) && import_typescript5.default.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === module && statement.importClause !== undefined && !statement.importClause.isTypeOnly && statement.importClause.namedBindings !== undefined && import_typescript5.default.isNamedImports(statement.importClause.namedBindings)), importedNames = (decl) => {
+  const bindings = decl.importClause?.namedBindings;
+  if (!bindings || !import_typescript5.default.isNamedImports(bindings))
+    return new Set;
+  return new Set(bindings.elements.map((element) => (element.propertyName ?? element.name).text));
+}, lastImportEnd = (sourceFile) => {
+  let end = 0;
+  for (const statement of sourceFile.statements) {
+    if (import_typescript5.default.isImportDeclaration(statement))
+      end = statement.getEnd();
+  }
+  return end;
+}, hasTypeImport = (sourceFile, module, local) => sourceFile.statements.some((statement) => import_typescript5.default.isImportDeclaration(statement) && import_typescript5.default.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === module && statement.getText().includes(local)), renderTypeImport = (spec) => {
+  if (spec.kind === "typeDefault") {
+    return `import type ${spec.local} from '${spec.module}';`;
+  }
+  if (spec.kind === "typeNamespace") {
+    return `import type * as ${spec.local} from '${spec.module}';`;
+  }
+  return "";
+}, groupNamed = (specs) => {
+  const byModule = new Map;
+  for (const spec of specs) {
+    if (spec.kind !== "named")
+      continue;
+    const set = byModule.get(spec.module) ?? new Set;
+    set.add(spec.name);
+    byModule.set(spec.module, set);
+  }
+  return byModule;
+}, mergeNamedEdit = (decl, sourceFile, missing) => {
+  const bindings = decl.importClause?.namedBindings;
+  if (!bindings || !import_typescript5.default.isNamedImports(bindings))
+    return null;
+  const { elements } = bindings;
+  const additions = missing.join(", ");
+  if (elements.length === 0) {
+    const insertAt2 = bindings.getStart(sourceFile) + 1;
+    return { end: insertAt2, start: insertAt2, text: additions };
+  }
+  const last = elements[elements.length - 1];
+  if (!last)
+    return null;
+  const insertAt = last.getEnd();
+  return { end: insertAt, start: insertAt, text: `, ${additions}` };
+}, missingNamesEdit = (decl, sourceFile, names) => {
+  const existing = importedNames(decl);
+  const missing = [...names].filter((name) => !existing.has(name));
+  return missing.length ? mergeNamedEdit(decl, sourceFile, missing) : null;
+}, buildImportEdits = (sourceFile, specs) => {
+  const edits = [];
+  const newLines = [];
+  for (const [module, names] of groupNamed(specs)) {
+    const decl = namedImportDecl(sourceFile, module);
+    const edit = decl ? missingNamesEdit(decl, sourceFile, names) : null;
+    if (edit)
+      edits.push(edit);
+    const fresh = `import { ${[...names].join(", ")} } from '${module}';`;
+    if (!decl)
+      newLines.push(fresh);
+  }
+  for (const spec of specs) {
+    if (spec.kind === "named")
+      continue;
+    if (hasTypeImport(sourceFile, spec.module, spec.local))
+      continue;
+    newLines.push(renderTypeImport(spec));
+  }
+  if (newLines.length > 0) {
+    const insertAt = lastImportEnd(sourceFile);
+    edits.push({
+      end: insertAt,
+      start: insertAt,
+      text: `
+${newLines.join(`
+`)}`
+    });
+  }
+  return edits;
+}, renderImportBlock = (specs) => {
+  const lines = [];
+  for (const [module, names] of groupNamed(specs)) {
+    lines.push(`import { ${[...names].join(", ")} } from '${module}';`);
+  }
+  for (const spec of specs) {
+    if (spec.kind !== "named")
+      lines.push(renderTypeImport(spec));
+  }
+  return lines.join(`
+`);
+}, hasChain = (path) => {
+  if (!existsSync14(path))
+    return false;
+  const sourceFile = parse2(path, readFileSync16(path, "utf-8"));
+  const found = findElysiaNew(sourceFile);
+  return found !== null;
+}, firstChainFile = (pluginsDir) => {
+  if (!existsSync14(pluginsDir))
+    return null;
+  for (const name of readdirSync4(pluginsDir)) {
+    if (!name.endsWith(".ts"))
+      continue;
+    const candidate = join15(pluginsDir, name);
+    if (hasChain(candidate))
+      return candidate;
+  }
+  return null;
+}, findRoutingFile = (serverEntry) => {
+  const pluginsDir = join15(dirname5(serverEntry), "plugins");
+  const preferred = join15(pluginsDir, "pagesPlugin.ts");
+  if (hasChain(preferred))
+    return preferred;
+  const scanned = firstChainFile(pluginsDir);
+  if (scanned)
+    return scanned;
+  if (hasChain(serverEntry))
+    return serverEntry;
+  return null;
+}, buildRouteContext = (input, routingFile) => {
+  const specifier = `${toModuleSpecifier(dirname5(routingFile), stripExtension(input.pageFileAbs))}${input.def.pageImportExtension ?? ""}`;
+  return {
+    cssAssetKey: input.cssAssetKey,
+    indexKey: input.indexKey,
+    manifestKey: input.manifestKey,
+    pageSpecifier: specifier,
+    pascal: input.pascal,
+    route: input.route,
+    title: input.title
+  };
+}, wirePluginUse = (serverEntry, pluginName, moduleSpecifier) => {
+  const specs = [
+    { kind: "named", module: moduleSpecifier, name: pluginName }
+  ];
+  const fallback = {
+    kind: "manual",
+    reason: "could not find an Elysia chain in the server entry",
+    snippet: `import { ${pluginName} } from '${moduleSpecifier}';
+
+.use(${pluginName})`
+  };
+  if (!hasChain(serverEntry))
+    return fallback;
+  const text = readFileSync16(serverEntry, "utf-8");
+  const sourceFile = parse2(serverEntry, text);
+  const newExpr = findElysiaNew(sourceFile);
+  if (!newExpr)
+    return fallback;
+  const top = climbChain(newExpr);
+  const { offset, separator } = findRouteInsertion(text, top);
+  const edits = buildImportEdits(sourceFile, specs);
+  edits.push({
+    end: offset,
+    start: offset,
+    text: `${separator}.use(${pluginName})`
+  });
+  writeFileSync6(serverEntry, applyEdits(text, edits), "utf-8");
+  return { kind: "edited", routingFile: serverEntry };
+}, wireRoute = (input) => {
+  const routingFile = findRoutingFile(input.serverEntry);
+  const ctx = routingFile ? buildRouteContext(input, routingFile) : buildRouteContext(input, input.serverEntry);
+  const specs = input.def.routeImports(ctx);
+  const routeExpr = input.def.routeExpression(ctx);
+  if (!routingFile) {
+    return {
+      kind: "manual",
+      reason: "could not find an Elysia route chain",
+      snippet: `${renderImportBlock(specs)}
+
+${routeExpr}`
+    };
+  }
+  const text = readFileSync16(routingFile, "utf-8");
+  const sourceFile = parse2(routingFile, text);
+  const newExpr = findElysiaNew(sourceFile);
+  if (!newExpr) {
+    return {
+      kind: "manual",
+      reason: "could not find an Elysia route chain",
+      snippet: `${renderImportBlock(specs)}
+
+${routeExpr}`
+    };
+  }
+  const top = climbChain(newExpr);
+  const { offset, separator } = findRouteInsertion(text, top);
+  const edits = buildImportEdits(sourceFile, specs);
+  edits.push({
+    end: offset,
+    start: offset,
+    text: `${separator}${routeExpr}`
+  });
+  writeFileSync6(routingFile, applyEdits(text, edits), "utf-8");
+  return { kind: "edited", routingFile };
+};
+var init_routeWiring = __esm(() => {
+  init_context();
+  import_typescript5 = __toESM(require_typescript(), 1);
+  BOUNDARY_USE = new Set(["absolutejs", "networking"]);
+});
+
+// src/cli/generate/generateApi.ts
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname6, join as join16 } from "path";
+var apiPluginTemplate = (pluginName, base) => `import { Elysia } from 'elysia';
+
+export const ${pluginName} = new Elysia()
+	.get('${base}', () => [])
+	.post('${base}', ({ body }) => body);
+`, generateApi = (project, rawName) => {
+  const camel = toCamelCase(rawName);
+  const kebab = toKebabCase(rawName);
+  const pluginName = `${camel}Plugin`;
+  const base = `/api/${kebab}`;
+  const outcome = { ...emptyOutcome(), route: base };
+  const pluginsDir = join16(dirname6(project.serverEntry), "plugins");
+  const fileAbs = join16(pluginsDir, `${pluginName}.ts`);
+  if (existsSync15(fileAbs)) {
+    outcome.notes.push(`${pluginName} already exists at ${fileAbs} \u2014 skipped.`);
+    return outcome;
+  }
+  mkdirSync7(pluginsDir, { recursive: true });
+  writeFileSync7(fileAbs, apiPluginTemplate(pluginName, base), "utf-8");
+  outcome.created.push(fileAbs);
+  const specifier = toModuleSpecifier(dirname6(project.serverEntry), fileAbs.replace(/\.ts$/, ""));
+  const wired = wirePluginUse(project.serverEntry, pluginName, specifier);
+  if (wired.kind === "edited")
+    outcome.updated.push(wired.routingFile);
+  else
+    outcome.manual = { reason: wired.reason, snippet: wired.snippet };
+  return outcome;
+};
+var init_generateApi = __esm(() => {
+  init_context();
+  init_routeWiring();
+});
+
+// src/cli/generate/componentTemplates.ts
+var reactComponent = (ctx) => `type ${ctx.pascal}Props = {
+	label: string;
+};
+
+export const ${ctx.pascal} = ({ label }: ${ctx.pascal}Props) => (
+	<button type="button">{label}</button>
+);
+`, svelteComponent = (ctx) => `<script lang="ts">
+	type ${ctx.pascal}Props = {
+		label: string;
+	};
+
+	let { label }: ${ctx.pascal}Props = $props();
+</script>
+
+<button type="button">{label}</button>
+`, vueComponent = () => `<script setup lang="ts">
+	defineProps<{
+		label: string;
+	}>();
+</script>
+
+<template>
+	<button type="button">{{ label }}</button>
+</template>
+`, angularComponent = (ctx) => `import { Component, input } from '@angular/core';
+
+@Component({
+	selector: 'app-${ctx.kebab}',
+	standalone: true,
+	template: \`<button type="button">{{ label() }}</button>\`
+})
+export class ${ctx.pascal}Component {
+	label = input('');
+}
+`, htmlComponent = (ctx) => `<button type="button">${ctx.title}</button>
+`, htmxComponent = (ctx) => `<button type="button" hx-get="/api/${ctx.kebab}" hx-swap="outerHTML">
+	${ctx.title}
+</button>
+`, componentTemplates;
+var init_componentTemplates = __esm(() => {
+  componentTemplates = {
+    angular: angularComponent,
+    html: htmlComponent,
+    htmx: htmxComponent,
+    react: reactComponent,
+    svelte: svelteComponent,
+    vue: vueComponent
+  };
+});
+
+// src/cli/generate/generateComponent.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname7, join as join17 } from "path";
+var generateComponent = (project, framework, rawName) => {
+  const def = frameworks2[framework];
+  const pascal = toPascalCase(rawName);
+  const kebab = toKebabCase(rawName);
+  const outcome = emptyOutcome();
+  const frameworkDir = project.frameworkDirs[framework];
+  if (!frameworkDir) {
+    outcome.manual = { reason: "framework directory missing", snippet: "" };
+    return outcome;
+  }
+  const fileAbs = join17(frameworkDir, "components", def.componentFile({ kebab, pascal }));
+  if (existsSync16(fileAbs)) {
+    outcome.notes.push(`${pascal} already exists at ${fileAbs} \u2014 skipped.`);
+    return outcome;
+  }
+  mkdirSync8(dirname7(fileAbs), { recursive: true });
+  writeFileSync8(fileAbs, componentTemplates[framework]({
+    kebab,
+    pascal,
+    title: toTitleCase(rawName)
+  }), "utf-8");
+  outcome.created.push(fileAbs);
+  return outcome;
+};
+var init_generateComponent = __esm(() => {
+  init_componentTemplates();
+  init_frameworks();
+});
+
+// src/cli/generate/cssStrategy.ts
+import { existsSync as existsSync17 } from "fs";
+import { join as join18 } from "path";
+var import_typescript6, CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
+	margin: 0 auto;
+	max-width: 64rem;
+	padding: 2rem;
+}
+`, cssAssetArg = (node) => {
+  if (!import_typescript6.default.isCallExpression(node) || !import_typescript6.default.isIdentifier(node.expression) || node.expression.text !== "asset") {
+    return null;
+  }
+  const [, arg] = node.arguments;
+  if (arg && import_typescript6.default.isStringLiteralLike(arg) && arg.text.endsWith(CSS_SUFFIX)) {
+    return arg.text;
+  }
+  return null;
+}, detectSharedKey = (routingText) => {
+  const sourceFile = import_typescript6.default.createSourceFile("routing.ts", routingText, import_typescript6.default.ScriptTarget.Latest, true);
+  let hoisted = null;
+  const inlineCounts = new Map;
+  const visit = (node) => {
+    const key = cssAssetArg(node);
+    if (key) {
+      if (import_typescript6.default.isVariableDeclaration(node.parent))
+        hoisted ??= key;
+      else
+        inlineCounts.set(key, (inlineCounts.get(key) ?? 0) + 1);
+    }
+    import_typescript6.default.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  if (hoisted)
+    return hoisted;
+  for (const [key, count] of inlineCounts) {
+    if (count >= SHARED_MIN_USES)
+      return key;
+  }
+  return null;
+}, fileForKey = (stylesDir, assetKey) => {
+  const base = assetKey.endsWith(CSS_SUFFIX) ? assetKey.slice(0, -CSS_SUFFIX.length) : assetKey;
+  return join18(stylesDir, `${toKebabCase(base)}.css`);
+}, planCss = (routingText, stylesDir, pascal, kebab) => {
+  const sharedKey = detectSharedKey(routingText);
+  if (sharedKey) {
+    const cssFileAbs2 = fileForKey(stylesDir, sharedKey);
+    return {
+      assetKey: sharedKey,
+      contents: DEFAULT_CSS,
+      create: !existsSync17(cssFileAbs2),
+      cssFileAbs: cssFileAbs2,
+      shared: true
+    };
+  }
+  const cssFileAbs = join18(stylesDir, `${kebab}.css`);
+  return {
+    assetKey: `${pascal}${CSS_SUFFIX}`,
+    contents: DEFAULT_CSS,
+    create: !existsSync17(cssFileAbs),
+    cssFileAbs,
+    shared: false
+  };
+};
+var init_cssStrategy = __esm(() => {
+  import_typescript6 = __toESM(require_typescript(), 1);
+});
+
+// src/cli/generate/navData.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync17, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname8 } from "path";
+var import_typescript7, NAV_DATA_TEMPLATE = `type NavItem = {
+	href: string;
+	label: string;
+};
+
+export const navData: NavItem[] = [];
+`, findNavArray = (sourceFile) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (import_typescript7.default.isVariableDeclaration(node) && import_typescript7.default.isIdentifier(node.name) && node.name.text === "navData" && node.initializer && import_typescript7.default.isArrayLiteralExpression(node.initializer)) {
+      found = node.initializer;
+      return;
+    }
+    import_typescript7.default.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}, readStringProperty = (object, name) => {
+  const property = object.properties.find((candidate) => import_typescript7.default.isPropertyAssignment(candidate) && import_typescript7.default.isIdentifier(candidate.name) && candidate.name.text === name);
+  if (!property || !import_typescript7.default.isStringLiteralLike(property.initializer)) {
+    return null;
+  }
+  return property.initializer.text;
+}, parseNavItems = (array) => {
+  const items = [];
+  for (const element of array.elements) {
+    if (!import_typescript7.default.isObjectLiteralExpression(element))
+      continue;
+    const href = readStringProperty(element, "href");
+    const label = readStringProperty(element, "label");
+    if (href !== null && label !== null)
+      items.push({ href, label });
+  }
+  return items;
+}, readNavItems = (navDataPath) => {
+  if (!existsSync18(navDataPath))
+    return [];
+  const text = readFileSync17(navDataPath, "utf-8");
+  const sourceFile = import_typescript7.default.createSourceFile(navDataPath, text, import_typescript7.default.ScriptTarget.Latest, true);
+  const array = findNavArray(sourceFile);
+  return array ? parseNavItems(array) : [];
+}, indentOf = (text, position) => {
+  let index = position;
+  while (index > 0 && text[index - 1] !== `
+`)
+    index -= 1;
+  let end = index;
+  while (text[end] === " " || text[end] === "\t")
+    end += 1;
+  return text.slice(index, end);
+}, insertElement = (text, array, sourceFile, entry) => {
+  const { elements } = array;
+  if (elements.length === 0) {
+    const insertAt2 = array.getStart(sourceFile) + 1;
+    const indent2 = `${indentOf(text, array.getStart(sourceFile))}	`;
+    const insertion2 = `
+${indent2}${entry}
+${indentOf(text, array.getStart(sourceFile))}`;
+    return text.slice(0, insertAt2) + insertion2 + text.slice(insertAt2);
+  }
+  const last = elements[elements.length - 1];
+  if (!last)
+    return text;
+  const indent = indentOf(text, last.getStart(sourceFile));
+  let insertAt = last.getEnd();
+  const hasComma = text[insertAt] === ",";
+  if (hasComma)
+    insertAt += 1;
+  const insertion = `${hasComma ? "" : ","}
+${indent}${entry}`;
+  return text.slice(0, insertAt) + insertion + text.slice(insertAt);
+}, upsertNavItem = (navDataPath, item) => {
+  const created = !existsSync18(navDataPath);
+  if (created) {
+    mkdirSync9(dirname8(navDataPath), { recursive: true });
+    writeFileSync9(navDataPath, NAV_DATA_TEMPLATE, "utf-8");
+  }
+  const existing = readNavItems(navDataPath);
+  if (existing.some((candidate) => candidate.href === item.href)) {
+    return { changed: created, created, items: existing };
+  }
+  const text = readFileSync17(navDataPath, "utf-8");
+  const sourceFile = import_typescript7.default.createSourceFile(navDataPath, text, import_typescript7.default.ScriptTarget.Latest, true);
+  const array = findNavArray(sourceFile);
+  if (!array)
+    return { changed: created, created, items: existing };
+  const entry = `{ href: '${item.href}', label: '${item.label}' }`;
+  writeFileSync9(navDataPath, insertElement(text, array, sourceFile, entry), "utf-8");
+  return { changed: true, created, items: [...existing, item] };
+};
+var init_navData = __esm(() => {
+  import_typescript7 = __toESM(require_typescript(), 1);
+});
+
+// src/cli/generate/staticNav.ts
+var NAV_MARKER_END = "<!-- /absolute:nav -->", NAV_MARKER_START = "<!-- absolute:nav -->", escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;"), indentBefore = (text, position) => {
+  let index = position;
+  while (index > 0 && text[index - 1] !== `
+`)
+    index -= 1;
+  return text.slice(index, position);
+}, renderNavBlock = (items, indent) => {
+  const links = items.map((item) => `${indent}	<a href="${escapeHtml(item.href)}">${escapeHtml(item.label)}</a>`).join(`
+`);
+  const body = links.length > 0 ? `
+${links}
+${indent}` : "";
+  return `${NAV_MARKER_START}
+${indent}<nav>${body}</nav>
+${indent}${NAV_MARKER_END}`;
+}, syncStaticNav = (html, items) => {
+  const startIdx = html.indexOf(NAV_MARKER_START);
+  const endIdx = html.indexOf(NAV_MARKER_END);
+  if (startIdx < 0 || endIdx < 0 || endIdx < startIdx)
+    return null;
+  const indent = indentBefore(html, startIdx);
+  const end = endIdx + NAV_MARKER_END.length;
+  return html.slice(0, startIdx) + renderNavBlock(items, indent) + html.slice(end);
+};
+
+// src/cli/generate/pageTemplates.ts
+var reactPage = (ctx) => `import { Head } from '@absolutejs/absolute/react/components';
+import { navData } from '${ctx.navImportPath}';
+
+type ${ctx.pascal}Props = {
+	cssPath?: string;
+};
+
+export const ${ctx.pascal} = ({ cssPath }: ${ctx.pascal}Props) => (
+	<html lang="en">
+		<Head cssPath={cssPath} title="${ctx.title}" />
+		<body>
+			<nav>
+				{navData.map((item) => (
+					<a key={item.href} href={item.href}>
+						{item.label}
+					</a>
+				))}
+			</nav>
+			<main>
+				<h1>${ctx.title}</h1>
+			</main>
+		</body>
+	</html>
+);
+`, sveltePage = (ctx) => `<script lang="ts">
+	import { navData } from '${ctx.navImportPath}';
+
+	type ${ctx.pascal}Props = {
+		cssPath?: string;
+	};
+
+	let { cssPath }: ${ctx.pascal}Props = $props();
+</script>
+
+<svelte:head>
+	{#if cssPath}
+		<link rel="stylesheet" href={cssPath} />
+	{/if}
+	<title>${ctx.title}</title>
+</svelte:head>
+
+<nav>
+	{#each navData as item (item.href)}
+		<a href={item.href}>{item.label}</a>
+	{/each}
+</nav>
+
+<main>
+	<h1>${ctx.title}</h1>
+</main>
+`, vuePage = (ctx) => `<script setup lang="ts">
+	import { navData } from '${ctx.navImportPath}';
+</script>
+
+<template>
+	<nav>
+		<a v-for="item in navData" :key="item.href" :href="item.href">
+			{{ item.label }}
+		</a>
+	</nav>
+	<main>
+		<h1>${ctx.title}</h1>
+	</main>
+</template>
+`, angularPage = (ctx) => `import { Component } from '@angular/core';
+import { navData } from '${ctx.navImportPath}';
+
+// This page has no per-request DI context, so the SSR handler's
+// \`requestContext\` is an empty object.
+export type Context = Record<string, never>;
+
+@Component({
+	imports: [],
+	selector: '${ctx.kebab}-page',
+	standalone: true,
+	template: \`
+		<nav>
+			@for (item of navItems; track item.href) {
+				<a [href]="item.href">{{ item.label }}</a>
+			}
+		</nav>
+		<main>
+			<h1>${ctx.title}</h1>
+		</main>
+	\`
+})
+export class ${ctx.pascal}Component {
+	navItems = navData;
+}
+`, htmlHead = (ctx, extraHead) => `<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<title>${ctx.title}</title>
+		<link rel="stylesheet" href="${ctx.cssHref}" />${extraHead}
+	</head>
+	<body>
+		${renderNavBlock(ctx.navItems, "\t\t")}
+		<main>
+			<h1>${ctx.title}</h1>
+		</main>
+	</body>
+</html>
+`, htmlPage = (ctx) => htmlHead(ctx, ""), htmxPage = (ctx) => htmlHead(ctx, `
+		<script src="/htmx/htmx.min.js"></script>`), pageTemplates;
+var init_pageTemplates = __esm(() => {
+  pageTemplates = {
+    angular: angularPage,
+    html: htmlPage,
+    htmx: htmxPage,
+    react: reactPage,
+    svelte: sveltePage,
+    vue: vuePage
+  };
+});
+
+// src/cli/generate/generatePage.ts
+import {
+  existsSync as existsSync19,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync18,
+  readdirSync as readdirSync5,
+  writeFileSync as writeFileSync10
+} from "fs";
+import { dirname as dirname9, join as join19, relative as relative4 } from "path";
+var writeNew = (path, contents) => {
+  mkdirSync10(dirname9(path), { recursive: true });
+  writeFileSync10(path, contents, "utf-8");
+}, toHref = (fromDir, toFile) => {
+  const rel = relative4(fromDir, toFile).split("\\").join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join19(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync19(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join19(pagesDir, name))), resyncPage = (file, items) => {
+  const html = readFileSync18(file, "utf-8");
+  const synced = syncStaticNav(html, items);
+  if (synced === null || synced === html)
+    return false;
+  writeFileSync10(file, synced, "utf-8");
+  return true;
+}, resyncStaticPages = (project, items, skipFile) => {
+  const updated = [];
+  for (const file of staticPageFiles(project)) {
+    if (file === skipFile)
+      continue;
+    if (resyncPage(file, items))
+      updated.push(file);
+  }
+  return updated;
+}, generatePage = (project, framework, rawName) => {
+  const def = frameworks2[framework];
+  const pascal = toPascalCase(rawName);
+  const kebab = toKebabCase(rawName);
+  const title = toTitleCase(rawName);
+  const route = `/${kebab}`;
+  const frameworkDir = project.frameworkDirs[framework];
+  const outcome = { ...emptyOutcome(), route };
+  if (!frameworkDir) {
+    outcome.manual = { reason: "framework directory missing", snippet: "" };
+    return outcome;
+  }
+  const pageFileAbs = join19(frameworkDir, "pages", def.pageFile({ kebab, pascal }));
+  if (existsSync19(pageFileAbs)) {
+    outcome.notes.push(`${pascal} already exists at ${pageFileAbs} \u2014 skipped.`);
+    return outcome;
+  }
+  const routingFile = findRoutingFile(project.serverEntry);
+  const routingText = routingFile ? readFileSync18(routingFile, "utf-8") : "";
+  const css = planCss(routingText, project.stylesDir, pascal, kebab);
+  const navDataPath = join19(sharedDirFor(project, framework), "navData.ts");
+  const nav = upsertNavItem(navDataPath, { href: route, label: title });
+  const navImportPath = toModuleSpecifier(dirname9(pageFileAbs), navDataPath.replace(/\.ts$/, ""));
+  writeNew(pageFileAbs, pageTemplates[framework]({
+    cssHref: toHref(dirname9(pageFileAbs), css.cssFileAbs),
+    kebab,
+    navImportPath,
+    navItems: nav.items,
+    pascal,
+    title
+  }));
+  outcome.created.push(pageFileAbs);
+  if (css.create) {
+    writeNew(css.cssFileAbs, css.contents);
+    outcome.created.push(css.cssFileAbs);
+  } else if (css.shared) {
+    outcome.notes.push(`Reusing shared stylesheet ${css.assetKey}.`);
+  }
+  if (nav.created)
+    outcome.created.push(navDataPath);
+  else if (nav.changed)
+    outcome.updated.push(navDataPath);
+  outcome.updated.push(...resyncStaticPages(project, nav.items, pageFileAbs));
+  const wired = wireRoute({
+    cssAssetKey: css.assetKey,
+    def,
+    indexKey: `${pascal}Index`,
+    manifestKey: pascal,
+    pageFileAbs,
+    pascal,
+    route,
+    serverEntry: project.serverEntry,
+    title
+  });
+  if (wired.kind === "edited")
+    outcome.updated.push(wired.routingFile);
+  else
+    outcome.manual = { reason: wired.reason, snippet: wired.snippet };
+  return outcome;
+};
+var init_generatePage = __esm(() => {
+  init_context();
+  init_cssStrategy();
+  init_frameworks();
+  init_navData();
+  init_pageTemplates();
+  init_routeWiring();
+});
+
+// src/cli/scripts/generate.ts
+var exports_generate = {};
+__export(exports_generate, {
+  runGenerate: () => runGenerate
+});
+import { relative as relative5 } from "path";
+var SUBCOMMANDS, write = (text) => process.stdout.write(`${text}
+`), fail = (message) => {
+  process.stdout.write(`${colors.red}${message}${colors.reset}
+`);
+  process.exitCode = 1;
+}, readArgs = (args) => {
+  const consumed = new Set;
+  const valueFlags = ["--config", "--framework"];
+  for (const flag of valueFlags) {
+    const idx = args.indexOf(flag);
+    if (idx < 0)
+      continue;
+    consumed.add(idx);
+    consumed.add(idx + 1);
+  }
+  const positionals = args.filter((value, idx) => !consumed.has(idx) && !value.startsWith("--"));
+  const flagValue = (flag) => {
+    const idx = args.indexOf(flag);
+    return idx >= 0 ? args[idx + 1] : undefined;
+  };
+  return {
+    config: flagValue("--config"),
+    framework: flagValue("--framework"),
+    name: positionals[1],
+    subcommand: positionals[0]
+  };
+}, printList = (label, paths, cwd) => {
+  if (paths.length === 0)
+    return;
+  write(`  ${colors.dim}${label}${colors.reset}`);
+  for (const path of paths)
+    write(`    ${relative5(cwd, path)}`);
+}, printSummary = (title, outcome, cwd) => {
+  for (const note of outcome.notes) {
+    write(`${colors.yellow}!${colors.reset} ${note}`);
+  }
+  if (outcome.created.length === 0 && outcome.updated.length === 0)
+    return;
+  write(`${colors.green}\u2713${colors.reset} Generated ${title}
+`);
+  printList("Created", outcome.created, cwd);
+  printList("Updated", outcome.updated, cwd);
+  if (outcome.route)
+    write(`
+  ${colors.dim}Route${colors.reset}  ${outcome.route}`);
+  if (outcome.manual) {
+    write(`
+  ${colors.yellow}Couldn't auto-wire the route${colors.reset} (${outcome.manual.reason}). Add manually:
+`);
+    for (const line of outcome.manual.snippet.split(`
+`))
+      write(`    ${line}`);
+  }
+  write(`
+  ${colors.dim}Next${colors.reset}  run \`absolute prettier --write\` to format edits, then \`absolute dev\``);
+}, runGenerate = async (args) => {
+  const { config, framework, name, subcommand } = readArgs(args);
+  if (!subcommand || !SUBCOMMANDS.has(subcommand)) {
+    fail("Usage: absolute generate <page|api|component> <name> [--framework <name>]");
+    return;
+  }
+  if (!isValidName(name)) {
+    fail(`Provide a name, e.g. \`absolute generate ${subcommand} dashboard\`.`);
+    return;
+  }
+  const cwd = process.cwd();
+  let project;
+  try {
+    project = await resolveProject(cwd, config);
+  } catch (error) {
+    fail(error instanceof Error ? error.message : String(error));
+    return;
+  }
+  if (subcommand === "api") {
+    printSummary(`api ${name}`, generateApi(project, name), cwd);
+    return;
+  }
+  const selected = selectFramework(project, framework);
+  if (!selected.ok) {
+    fail(selected.message);
+    return;
+  }
+  const outcome = subcommand === "page" ? generatePage(project, selected.framework, name) : generateComponent(project, selected.framework, name);
+  printSummary(`${subcommand} ${name} (${selected.framework})`, outcome, cwd);
+};
+var init_generate = __esm(() => {
+  init_context();
+  init_generateApi();
+  init_generateComponent();
+  init_generatePage();
+  init_tuiPrimitives();
+  SUBCOMMANDS = new Set(["api", "component", "page"]);
+});
+
 // src/cli/scripts/env.ts
 var exports_env = {};
 __export(exports_env, {
@@ -172053,15 +173198,15 @@ __export(exports_env, {
   runEnv: () => runEnv,
   collectEnvVars: () => collectEnvVars
 });
-import { existsSync as existsSync13, readFileSync as readFileSync15 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync19 } from "fs";
+import { join as join20 } from "path";
 var {env: env3, Glob: Glob3 } = globalThis.Bun;
-var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH, keysInFile = (text) => [...text.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync13(join14(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
+var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH, keysInFile = (text) => [...text.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync20(join20(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
   const scans = scanPatterns().map((pattern) => Array.fromAsync(new Glob3(pattern).scan({ cwd: process.cwd() })));
   const files = (await Promise.all(scans)).flat();
   const usage = new Map;
   files.forEach((file) => {
-    keysInFile(readFileSync15(file, "utf-8")).forEach((key) => {
+    keysInFile(readFileSync19(file, "utf-8")).forEach((key) => {
       usage.set(key, [...usage.get(key) ?? [], file]);
     });
   });
@@ -172119,7 +173264,7 @@ __export(exports_logs, {
 });
 import {
   closeSync as closeSync2,
-  existsSync as existsSync14,
+  existsSync as existsSync21,
   openSync as openSync4,
   readSync as readSync2,
   statSync as statSync2,
@@ -172186,7 +173331,7 @@ var DEFAULT_LINES = 40, POLL_MS = 250, LINES_FLAG_SPAN = 2, readFrom = (path, st
     printAvailable(instances);
     return;
   }
-  if (match.logFile === null || !existsSync14(match.logFile)) {
+  if (match.logFile === null || !existsSync21(match.logFile)) {
     printDim2(`"${name}" has no captured log (untracked, or started outside the CLI).`);
     return;
   }
@@ -172209,10 +173354,10 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import { createRequire } from "module";
 import { arch as arch4, platform as platform5 } from "os";
-import { join as join15 } from "path";
+import { join as join21 } from "path";
 var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
   detail,
   label,
@@ -172247,7 +173392,7 @@ var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
     return [];
   const label = `${field.replace("Directory", "")} pages`;
   return [
-    existsSync15(join15(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
+    existsSync22(join21(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
   ];
 }), envCheck = async () => {
   const vars = await collectEnvVars();
@@ -172317,7 +173462,7 @@ var init_doctor = __esm(() => {
     "htmlDirectory",
     "htmxDirectory"
   ];
-  projectRequire = createRequire(join15(process.cwd(), "package.json"));
+  projectRequire = createRequire(join21(process.cwd(), "package.json"));
   STATUS_MARK = {
     fail: `${colors.red}\u2717${colors.reset}`,
     ok: `${colors.green}\u2713${colors.reset}`,
@@ -172398,13 +173543,13 @@ var init_routes = __esm(() => {
 });
 
 // src/build/externalAssetPlugin.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync16, mkdirSync as mkdirSync7, statSync as statSync3 } from "fs";
-import { basename as basename6, dirname as dirname4, join as join16, resolve as resolve11 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync23, mkdirSync as mkdirSync11, statSync as statSync3 } from "fs";
+import { basename as basename6, dirname as dirname10, join as join22, resolve as resolve13 } from "path";
 var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
   name: "absolute-external-asset",
   setup(bld) {
     const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
-    const skipRoots = userSourceRoots.map((root) => resolve11(root));
+    const skipRoots = userSourceRoots.map((root) => resolve13(root));
     const isUserSource = (path) => skipRoots.some((root) => path.startsWith(`${root}/`));
     bld.onLoad({ filter: /\.[mc]?[jt]sx?$/ }, async (args) => {
       if (isUserSource(args.path))
@@ -172414,20 +173559,20 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
         return;
       urlPattern.lastIndex = 0;
       let match;
-      const sourceDir = dirname4(args.path);
+      const sourceDir = dirname10(args.path);
       while ((match = urlPattern.exec(source)) !== null) {
         const relPath = match[1];
         if (!relPath)
           continue;
-        const assetPath = resolve11(sourceDir, relPath);
-        if (!existsSync16(assetPath))
+        const assetPath = resolve13(sourceDir, relPath);
+        if (!existsSync23(assetPath))
           continue;
         if (!statSync3(assetPath).isFile())
           continue;
-        const targetPath = join16(outDir, basename6(assetPath));
-        if (existsSync16(targetPath))
+        const targetPath = join22(outDir, basename6(assetPath));
+        if (existsSync23(targetPath))
           continue;
-        mkdirSync7(dirname4(targetPath), { recursive: true });
+        mkdirSync11(dirname10(targetPath), { recursive: true });
         copyFileSync2(assetPath, targetPath);
       }
       return;
@@ -172445,16 +173590,16 @@ __export(exports_compile, {
 var {env: env4 } = globalThis.Bun;
 import {
   cpSync,
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync8,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync16,
+  existsSync as existsSync24,
+  mkdirSync as mkdirSync12,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync20,
   rmSync as rmSync5,
   statSync as statSync4,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync11
 } from "fs";
-import { basename as basename7, dirname as dirname5, join as join17, relative as relative3, resolve as resolve12 } from "path";
+import { basename as basename7, dirname as dirname11, join as join23, relative as relative6, resolve as resolve14 } from "path";
 var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, compileBanner = (version2) => {
   const resolvedVersion = version2 || "unknown";
   console.log("");
@@ -172462,14 +173607,14 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   console.log("");
 }, collectFiles2 = (dir) => {
   const result = [];
-  let pending = readdirSync4(dir, { withFileTypes: true });
+  let pending = readdirSync6(dir, { withFileTypes: true });
   while (pending.length > 0) {
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join17(entry.parentPath, entry.name);
+    const fullPath = join23(entry.parentPath, entry.name);
     if (entry.isDirectory())
-      pending = pending.concat(readdirSync4(fullPath, { withFileTypes: true }));
+      pending = pending.concat(readdirSync6(fullPath, { withFileTypes: true }));
     else
       result.push(fullPath);
   }
@@ -172482,16 +173627,16 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return `./${parts.join("/")}`;
 }, collectProjectSourceFiles = (dir) => {
   const result = [];
-  let pending = readdirSync4(dir, { withFileTypes: true });
+  let pending = readdirSync6(dir, { withFileTypes: true });
   while (pending.length > 0) {
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join17(entry.parentPath, entry.name);
+    const fullPath = join23(entry.parentPath, entry.name);
     if (entry.isDirectory()) {
       if (SERVER_RUNTIME_SCAN_SKIP_DIRS.has(entry.name))
         continue;
-      pending = pending.concat(readdirSync4(fullPath, { withFileTypes: true }));
+      pending = pending.concat(readdirSync6(fullPath, { withFileTypes: true }));
     } else if (hasSourceExtension(fullPath)) {
       result.push(fullPath);
     }
@@ -172499,22 +173644,22 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return result;
 }, copyServerRuntimeAssetReferences = (outdir) => {
   const copied = new Set;
-  const normalizedOutdir = resolve12(outdir);
+  const normalizedOutdir = resolve14(outdir);
   const copyReference = (filePath, relPath) => {
-    const assetSource = resolve12(dirname5(filePath), relPath);
-    if (!existsSync17(assetSource) || !statSync4(assetSource).isFile())
+    const assetSource = resolve14(dirname11(filePath), relPath);
+    if (!existsSync24(assetSource) || !statSync4(assetSource).isFile())
       return;
-    const assetTarget = resolve12(normalizedOutdir, relPath.replace(/^\.\//, ""));
+    const assetTarget = resolve14(normalizedOutdir, relPath.replace(/^\.\//, ""));
     if (assetTarget !== normalizedOutdir && !assetTarget.startsWith(`${normalizedOutdir}/`))
       return;
     if (copied.has(assetTarget))
       return;
     copied.add(assetTarget);
-    mkdirSync8(dirname5(assetTarget), { recursive: true });
+    mkdirSync12(dirname11(assetTarget), { recursive: true });
     cpSync(assetSource, assetTarget, { force: true });
   };
   for (const filePath of collectProjectSourceFiles(process.cwd())) {
-    const source = readFileSync16(filePath, "utf-8");
+    const source = readFileSync20(filePath, "utf-8");
     SERVER_RUNTIME_ASSET_RE.lastIndex = 0;
     let match;
     while ((match = SERVER_RUNTIME_ASSET_RE.exec(source)) !== null) {
@@ -172543,7 +173688,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
 }, readPackageVersion4 = (candidate) => {
   try {
-    const pkg = JSON.parse(readFileSync16(candidate, "utf-8"));
+    const pkg = JSON.parse(readFileSync20(candidate, "utf-8"));
     if (pkg.name !== "@absolutejs/absolute")
       return null;
     const ver = pkg.version;
@@ -172578,18 +173723,18 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return resolveBuildModule3(remaining);
 }, resolveJsxDevRuntimeCompatPath2 = () => {
   const candidates = [
-    resolve12(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve12(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve12(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
-    resolve12(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve12(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve12(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve14(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve14(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve14(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
+    resolve14(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve14(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve14(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
-    if (existsSync17(candidate))
+    if (existsSync24(candidate))
       return candidate;
   }
-  return resolve12(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
+  return resolve14(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
 }, jsxDevRuntimeCompatPath2, shouldEmbedCompiledAsset = (relativePath, skip = new Set) => {
   if (skip.has(relativePath))
     return false;
@@ -172602,11 +173747,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return true;
 }, tryReadNodePackageJson = (packageDir) => {
   try {
-    return JSON.parse(readFileSync16(join17(packageDir, "package.json"), "utf-8"));
+    return JSON.parse(readFileSync20(join23(packageDir, "package.json"), "utf-8"));
   } catch {
     return null;
   }
-}, resolveProjectPackageDir = (specifier) => resolve12(process.cwd(), "node_modules", ...specifier.split("/")), copyPackageToBuild = (specifier, outdir, seen) => {
+}, resolveProjectPackageDir = (specifier) => resolve14(process.cwd(), "node_modules", ...specifier.split("/")), copyPackageToBuild = (specifier, outdir, seen) => {
   if (seen.has(specifier))
     return;
   const srcDir = resolveProjectPackageDir(specifier);
@@ -172614,13 +173759,13 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!pkg)
     return;
   seen.add(specifier);
-  const destDir = join17(outdir, "node_modules", ...specifier.split("/"));
+  const destDir = join23(outdir, "node_modules", ...specifier.split("/"));
   rmSync5(destDir, { force: true, recursive: true });
   cpSync(srcDir, destDir, {
     force: true,
     recursive: true,
     filter(source) {
-      const rel = relative3(srcDir, source);
+      const rel = relative6(srcDir, source);
       const [firstSegment] = rel.split(/[\\/]/);
       return firstSegment !== "node_modules" && firstSegment !== ".git";
     }
@@ -172636,8 +173781,8 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
 }, copyAngularRuntimePackages = (buildConfig, outdir) => {
   if (!buildConfig.angularDirectory)
     return;
-  const angularScopeDir = resolve12(process.cwd(), "node_modules", "@angular");
-  const angularPackages = existsSync17(angularScopeDir) ? readdirSync4(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
+  const angularScopeDir = resolve14(process.cwd(), "node_modules", "@angular");
+  const angularPackages = existsSync24(angularScopeDir) ? readdirSync6(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
   const roots = new Set([...angularPackages, "rxjs", "tslib", "typescript"]);
   const seen = new Set;
   for (const specifier of roots) {
@@ -172654,16 +173799,16 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
   copyAngularRuntimePackages(buildConfig, outdir);
 }, collectRuntimePackageSpecifiers = (distDir) => {
-  const nodeModulesDir = join17(distDir, "node_modules");
-  if (!existsSync17(nodeModulesDir))
+  const nodeModulesDir = join23(distDir, "node_modules");
+  if (!existsSync24(nodeModulesDir))
     return [];
   const specifiers = [];
-  for (const entry of readdirSync4(nodeModulesDir, { withFileTypes: true })) {
+  for (const entry of readdirSync6(nodeModulesDir, { withFileTypes: true })) {
     if (!entry.isDirectory())
       continue;
     if (entry.name.startsWith("@")) {
-      const scopeDir = join17(nodeModulesDir, entry.name);
-      for (const scopedEntry of readdirSync4(scopeDir, {
+      const scopeDir = join23(nodeModulesDir, entry.name);
+      for (const scopedEntry of readdirSync6(scopeDir, {
         withFileTypes: true
       })) {
         if (scopedEntry.isDirectory()) {
@@ -172676,7 +173821,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
   return specifiers.sort((a, b) => b.length - a.length);
 }, ensureRelativeModuleSpecifier = (fromFile, toFile) => {
-  const rel = relative3(dirname5(fromFile), toFile).replace(/\\/g, "/");
+  const rel = relative6(dirname11(fromFile), toFile).replace(/\\/g, "/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }, pickExportEntry = (value) => {
   if (typeof value === "string")
@@ -172694,18 +173839,18 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const packageSpecifier = packageSpecifiers.find((root) => specifier === root || specifier.startsWith(`${root}/`));
   if (!packageSpecifier)
     return null;
-  const packageDir = join17(distDir, "node_modules", ...packageSpecifier.split("/"));
+  const packageDir = join23(distDir, "node_modules", ...packageSpecifier.split("/"));
   const subpath = specifier.slice(packageSpecifier.length);
-  const subPackageDir = subpath ? join17(packageDir, ...subpath.slice(1).split("/")) : null;
-  const resolvedPackageDir = subPackageDir && existsSync17(join17(subPackageDir, "package.json")) ? subPackageDir : packageDir;
-  const packageJsonPath = join17(resolvedPackageDir, "package.json");
-  if (!existsSync17(packageJsonPath))
+  const subPackageDir = subpath ? join23(packageDir, ...subpath.slice(1).split("/")) : null;
+  const resolvedPackageDir = subPackageDir && existsSync24(join23(subPackageDir, "package.json")) ? subPackageDir : packageDir;
+  const packageJsonPath = join23(resolvedPackageDir, "package.json");
+  if (!existsSync24(packageJsonPath))
     return null;
-  const pkg = JSON.parse(readFileSync16(packageJsonPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync20(packageJsonPath, "utf-8"));
   const exportKey = resolvedPackageDir !== subPackageDir && subpath ? `.${subpath}` : ".";
   const rootExport = pkg.exports?.[exportKey];
   const entry = pickExportEntry(rootExport) ?? (resolvedPackageDir === subPackageDir || !subpath ? pkg.module ?? pkg.main ?? "index.js" : `.${subpath}`);
-  return join17(resolvedPackageDir, entry);
+  return join23(resolvedPackageDir, entry);
 }, RUNTIME_JS_EXTENSIONS, MODULE_SPECIFIER_RE, isRuntimeJsFile = (filePath) => RUNTIME_JS_EXTENSIONS.some((extension) => filePath.endsWith(extension)), isNodeModulesPath = (filePath) => filePath.split(/[\\/]/).includes("node_modules"), isFile = (filePath) => {
   try {
     return statSync4(filePath).isFile();
@@ -172718,16 +173863,16 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const candidates = [
     candidate,
     ...RUNTIME_JS_EXTENSIONS.map((extension) => `${candidate}${extension}`),
-    ...RUNTIME_JS_EXTENSIONS.map((extension) => join17(candidate, `index${extension}`))
+    ...RUNTIME_JS_EXTENSIONS.map((extension) => join23(candidate, `index${extension}`))
   ];
   return candidates.find((filePath) => isRuntimeJsFile(filePath) && isFile(filePath)) ?? null;
 }, findContainingRuntimePackageDir = (filePath) => {
-  let dir = dirname5(filePath);
-  while (dir !== dirname5(dir)) {
-    if (isNodeModulesPath(dir) && existsSync17(join17(dir, "package.json"))) {
+  let dir = dirname11(filePath);
+  while (dir !== dirname11(dir)) {
+    if (isNodeModulesPath(dir) && existsSync24(join23(dir, "package.json"))) {
       return dir;
     }
-    dir = dirname5(dir);
+    dir = dirname11(dir);
   }
   return null;
 }, resolvePackageImportEntryFile = (fromFile, specifier) => {
@@ -172740,7 +173885,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const entry = pickExportEntry(pkg?.imports?.[specifier]);
   if (!entry)
     return null;
-  return join17(packageDir, entry);
+  return join23(packageDir, entry);
 }, collectRuntimeRewriteRoots = (distDir) => collectFiles2(distDir).filter((filePath) => isRuntimeJsFile(filePath) && !isNodeModulesPath(filePath)), rewriteRuntimeModuleSpecifiers = (distDir) => {
   const packageSpecifiers = collectRuntimePackageSpecifiers(distDir);
   if (packageSpecifiers.length === 0)
@@ -172759,10 +173904,10 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (!filePath || seen.has(filePath))
       continue;
     seen.add(filePath);
-    const source = readFileSync16(filePath, "utf-8");
+    const source = readFileSync20(filePath, "utf-8");
     const rewritten = source.replace(MODULE_SPECIFIER_RE, (match, prefix, quote, specifier) => {
       if (typeof specifier === "string" && specifier.startsWith(".")) {
-        enqueue(resolveRuntimeJsFile(resolve12(dirname5(filePath), specifier)));
+        enqueue(resolveRuntimeJsFile(resolve14(dirname11(filePath), specifier)));
         return match;
       }
       const packageImportTarget = resolveRuntimeJsFile(resolvePackageImportEntryFile(filePath, specifier) ?? "");
@@ -172777,7 +173922,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
       return `${prefix}${quote}${ensureRelativeModuleSpecifier(filePath, target)}${quote}`;
     });
     if (rewritten !== source) {
-      writeFileSync6(filePath, rewritten);
+      writeFileSync11(filePath, rewritten);
     }
   }
 }, generateEntrypoint = (distDir, serverEntry, prerenderMap, version2, buildConfig) => {
@@ -172790,25 +173935,25 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     "_compile_entrypoint.ts"
   ]);
   const embeddedFiles = allFiles.filter((file) => {
-    const rel = relative3(distDir, file);
+    const rel = relative6(distDir, file);
     if (embeddedSkip.has(rel))
       return false;
     return true;
   });
-  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative3(distDir, file), assetSkip));
+  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative6(distDir, file), assetSkip));
   const imports = [];
   const embeddedMappings = [];
   const mappings = [];
   const embeddedVarMap = new Map;
   embeddedFiles.forEach((filePath, idx) => {
-    const rel = relative3(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative6(distDir, filePath).replace(/\\/g, "/");
     const varName = `__a${idx}`;
     embeddedVarMap.set(rel, varName);
     imports.push(`import ${varName} from "./${rel}" with { type: "file" };`);
     embeddedMappings.push(`	["${rel}", ${varName}],`);
   });
   clientFiles.forEach((filePath) => {
-    const rel = relative3(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative6(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (!varName)
       return;
@@ -172822,7 +173967,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const pageVarMap = new Map;
   const prerenderEntries = Array.from(prerenderMap.entries());
   prerenderEntries.forEach(([route, filePath]) => {
-    const rel = relative3(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative6(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (varName)
       pageVarMap.set(route, varName);
@@ -172851,7 +173996,7 @@ import { websocket as elysiaWebsocket } from "elysia/ws";
 const SERVER_MODULE = (runtimeDir: string) => import(pathToFileURL(join(runtimeDir, ${JSON.stringify(serverBundleName)})).href);
 const RUNTIME_BUILD_ID = ${JSON.stringify(runtimeBuildId)};
 const RUNTIME_CONFIG_SOURCE = ${JSON.stringify(runtimeConfigSource)};
-const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve12(distDir))};
+const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve14(distDir))};
 const ORIGINAL_BUILD_DIR_NORMALIZED = ORIGINAL_BUILD_DIR.replace(/\\\\/g, "/");
 
 // \u2500\u2500 Asset URL \u2192 embedded path map \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
@@ -173229,16 +174374,16 @@ console.log(\`
   }),
   ...collectUserServerExternals(buildConfig)
 ], compile = async (serverEntry, outdir, outfile, configPath2) => {
-  const resolvedOutdir = resolve12(outdir ?? "dist");
+  const resolvedOutdir = resolve14(outdir ?? "dist");
   await withBuildDirectoryLock(resolvedOutdir, () => compileUnlocked(serverEntry, resolvedOutdir, outfile, configPath2));
 }, compileUnlocked = async (serverEntry, resolvedOutdir, outfile, configPath2) => {
   const prerenderPort = Number(env4.COMPILE_PORT) || Number(env4.PORT) || DEFAULT_PORT + 1;
   killStaleProcesses(prerenderPort);
   const entryName = basename7(serverEntry).replace(/\.[^.]+$/, "");
-  const resolvedOutfile = resolve12(outfile ?? "compiled-server");
+  const resolvedOutfile = resolve14(outfile ?? "compiled-server");
   const absoluteVersion = resolvePackageVersion3([
-    resolve12(import.meta.dir, "..", "..", "..", "package.json"),
-    resolve12(import.meta.dir, "..", "..", "package.json")
+    resolve14(import.meta.dir, "..", "..", "..", "package.json"),
+    resolve14(import.meta.dir, "..", "..", "package.json")
   ]);
   compileBanner(absoluteVersion);
   const totalStart = performance.now();
@@ -173249,8 +174394,8 @@ console.log(\`
   buildConfig.mode = "production";
   try {
     const build2 = await resolveBuildModule3([
-      resolve12(import.meta.dir, "..", "..", "core", "build"),
-      resolve12(import.meta.dir, "..", "build")
+      resolve14(import.meta.dir, "..", "..", "core", "build"),
+      resolve14(import.meta.dir, "..", "build")
     ]);
     if (!build2)
       throw new Error("Could not locate build module");
@@ -173272,10 +174417,10 @@ console.log(\`
     buildConfig.htmxDirectory
   ].filter((dir) => Boolean(dir));
   const islandRegistrySpec = buildConfig.islands?.registry;
-  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve12(islandRegistrySpec))) : undefined;
+  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve14(islandRegistrySpec))) : undefined;
   const serverBundle = await Bun.build({
     define: { "process.env.NODE_ENV": '"production"' },
-    entrypoints: [resolve12(serverEntry)],
+    entrypoints: [resolve14(serverEntry)],
     external: resolveServerBundleExternals(buildConfig),
     outdir: resolvedOutdir,
     plugins: [
@@ -173296,14 +174441,14 @@ console.log(\`
     console.error(cliTag4("\x1B[31m", "Server bundle failed."));
     process.exit(1);
   }
-  const outputPath = resolve12(resolvedOutdir, `${entryName}.js`);
-  if (!existsSync17(outputPath)) {
+  const outputPath = resolve14(resolvedOutdir, `${entryName}.js`);
+  if (!existsSync24(outputPath)) {
     console.error(cliTag4("\x1B[31m", `Expected output not found: ${outputPath}`));
     process.exit(1);
   }
-  if (existsSync17(resolve12(resolvedOutdir, "angular", "vendor", "server"))) {
-    const vendorDir = resolve12(resolvedOutdir, "angular", "vendor", "server");
-    const vendorEntries = readdirSync4(vendorDir).filter((f) => f.endsWith(".js"));
+  if (existsSync24(resolve14(resolvedOutdir, "angular", "vendor", "server"))) {
+    const vendorDir = resolve14(resolvedOutdir, "angular", "vendor", "server");
+    const vendorEntries = readdirSync6(vendorDir).filter((f) => f.endsWith(".js"));
     const angularServerVendorPaths = {};
     for (const file of vendorEntries) {
       const stem = file.replace(/\.js$/, "");
@@ -173311,7 +174456,7 @@ console.log(\`
       if (scope !== "angular" || rest.length === 0)
         continue;
       const specifier = `@angular/${rest.join("/")}`;
-      const relPath = relative3(dirname5(outputPath), resolve12(vendorDir, file));
+      const relPath = relative6(dirname11(outputPath), resolve14(vendorDir, file));
       angularServerVendorPaths[specifier] = relPath.startsWith(".") ? relPath : `./${relPath}`;
     }
     if (Object.keys(angularServerVendorPaths).length > 0) {
@@ -173323,7 +174468,7 @@ console.log(\`
   copyServerRuntimeAssetReferences(resolvedOutdir);
   const prerenderStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Pre-rendering pages"));
-  rmSync5(join17(resolvedOutdir, "_prerendered"), {
+  rmSync5(join23(resolvedOutdir, "_prerendered"), {
     force: true,
     recursive: true
   });
@@ -173342,9 +174487,9 @@ console.log(\`
   const compileStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Compiling standalone executable"));
   const entrypointCode = generateEntrypoint(resolvedOutdir, serverEntry, prerenderMap, absoluteVersion, buildConfig);
-  const entrypointPath = join17(resolvedOutdir, "_compile_entrypoint.ts");
+  const entrypointPath = join23(resolvedOutdir, "_compile_entrypoint.ts");
   await Bun.write(entrypointPath, entrypointCode);
-  mkdirSync8(dirname5(resolvedOutfile), { recursive: true });
+  mkdirSync12(dirname11(resolvedOutfile), { recursive: true });
   const result = await Bun.build({
     compile: { outfile: resolvedOutfile },
     define: { "process.env.NODE_ENV": '"production"' },
@@ -173438,11 +174583,11 @@ var exports_typecheck = {};
 __export(exports_typecheck, {
   typecheck: () => typecheck
 });
-import { resolve as resolve13, join as join18 } from "path";
-import { existsSync as existsSync18, readFileSync as readFileSync17 } from "fs";
+import { resolve as resolve15, join as join24 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync21 } from "fs";
 import { mkdir as mkdir2, writeFile } from "fs/promises";
-var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve13(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
-  if (!existsSync18(resolveConfigPath(configPath2))) {
+var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve15(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
+  if (!existsSync25(resolveConfigPath(configPath2))) {
     return [{}];
   }
   const rawConfig = await loadRawConfig(configPath2);
@@ -173462,8 +174607,8 @@ var isCommandService3 = (service) => service.kind === "command" || Array.isArray
   const exitCode = await proc.exited;
   return { exitCode, name, output: (stdout + stderr).trim() };
 }, shellEscape = (value) => `'${value.replaceAll("'", "'\\''")}'`, runShell = async (name, command) => run(name, ["/bin/bash", "-lc", command]), findBin = (name) => {
-  const local = resolve13("node_modules", ".bin", name);
-  return existsSync18(local) ? local : null;
+  const local = resolve15("node_modules", ".bin", name);
+  return existsSync25(local) ? local : null;
 }, ANSI_COLOR_REGEX, ANSI_PURPLE_REGEX, ANSI_CYAN_REGEX, ANSI_TOKEN_END_REGEX, stripAnsi3 = (str) => str.replace(ANSI_COLOR_REGEX, ""), formatSvelteOutput = (output) => {
   const cwd = `${process.cwd()}/`;
   const summaryMatch = stripAnsi3(output).match(/svelte-check found (\d+) error/);
@@ -173510,15 +174655,15 @@ Found ${errorCount} error${suffix}.`;
   return formatted;
 }, ABSOLUTE_INTERNAL_EXCLUDES, resolveAbsoluteTypeFile = (fileName) => {
   const candidates = [
-    resolve13("node_modules/@absolutejs/absolute/dist/types", fileName),
-    resolve13(import.meta.dir, "../types", fileName),
-    resolve13(import.meta.dir, "../../types", fileName),
-    resolve13(import.meta.dir, "../../../types", fileName)
+    resolve15("node_modules/@absolutejs/absolute/dist/types", fileName),
+    resolve15(import.meta.dir, "../types", fileName),
+    resolve15(import.meta.dir, "../../types", fileName),
+    resolve15(import.meta.dir, "../../../types", fileName)
   ];
-  return candidates.find((candidate) => existsSync18(candidate)) ?? candidates[0];
+  return candidates.find((candidate) => existsSync25(candidate)) ?? candidates[0];
 }, ABSOLUTE_TYPECHECK_FILES, readProjectTsconfig = () => {
   try {
-    return JSON.parse(readFileSync17(resolve13("tsconfig.json"), "utf-8"));
+    return JSON.parse(readFileSync21(resolve15("tsconfig.json"), "utf-8"));
   } catch {
     return {};
   }
@@ -173546,22 +174691,22 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m vue-tsc is required for Vue type checking. Install it: bun add -d vue-tsc");
     process.exit(1);
   }
-  const vueTsconfigPath = join18(cacheDir, "tsconfig.vue-check.json");
+  const vueTsconfigPath = join24(cacheDir, "tsconfig.vue-check.json");
   return writeFile(vueTsconfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve13("tsconfig.json"),
+    extends: resolve15("tsconfig.json"),
     include: getProjectTypecheckIncludes()
   }, null, "\t")).then(() => run("vue-tsc", [
     vueTscBin,
     "--noEmit",
     "--project",
-    resolve13(vueTsconfigPath),
+    resolve15(vueTsconfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join18(cacheDir, "vue-tsc.tsbuildinfo"),
+    join24(cacheDir, "vue-tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildAngularCheck = async (cacheDir, angularDir) => {
@@ -173570,7 +174715,7 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m @angular/compiler-cli is required for Angular type checking. Install it: bun add -d @angular/compiler-cli");
     process.exit(1);
   }
-  const angularTsconfigPath = join18(cacheDir, "tsconfig.angular-check.json");
+  const angularTsconfigPath = join24(cacheDir, "tsconfig.angular-check.json");
   await writeFile(angularTsconfigPath, JSON.stringify({
     angularCompilerOptions: {
       strictTemplates: true
@@ -173580,32 +174725,32 @@ Found ${errorCount} error${suffix}.`;
       rootDir: ".."
     },
     exclude: ABSOLUTE_INTERNAL_EXCLUDES.map(toGeneratedConfigPath),
-    extends: resolve13("tsconfig.json"),
+    extends: resolve15("tsconfig.json"),
     include: [`../${angularDir}/**/*`]
   }, null, "\t"));
-  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve13(angularTsconfigPath))}`);
+  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve15(angularTsconfigPath))}`);
 }, buildTscCheck = (cacheDir) => {
   const tscBin = findBin("tsc");
   if (!tscBin) {
     console.error("\x1B[31m\u2717\x1B[0m typescript is required for type checking. Install it: bun add -d typescript");
     process.exit(1);
   }
-  const tscConfigPath = join18(cacheDir, "tsconfig.typecheck.json");
+  const tscConfigPath = join24(cacheDir, "tsconfig.typecheck.json");
   return writeFile(tscConfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve13("tsconfig.json"),
+    extends: resolve15("tsconfig.json"),
     include: getProjectTypecheckIncludes()
   }, null, "\t")).then(() => run("tsc", [
     tscBin,
     "--noEmit",
     "--project",
-    resolve13(tscConfigPath),
+    resolve15(tscConfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join18(cacheDir, "tsc.tsbuildinfo"),
+    join24(cacheDir, "tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildSvelteCheck = async (cacheDir, svelteDir) => {
@@ -173614,16 +174759,16 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m svelte-check is required for Svelte type checking. Install it: bun add -d svelte-check");
     process.exit(1);
   }
-  const svelteTsconfigPath = join18(cacheDir, "tsconfig.svelte-check.json");
+  const svelteTsconfigPath = join24(cacheDir, "tsconfig.svelte-check.json");
   await writeFile(svelteTsconfigPath, JSON.stringify({
-    extends: resolve13("tsconfig.json"),
+    extends: resolve15("tsconfig.json"),
     files: ABSOLUTE_TYPECHECK_FILES,
     include: [`../${svelteDir}/**/*`]
   }, null, "\t"));
   return run("svelte-check", [
     svelteBin,
     "--tsconfig",
-    resolve13(svelteTsconfigPath),
+    resolve15(svelteTsconfigPath),
     "--threshold",
     "error",
     "--compiler-warnings",
@@ -173812,11 +174957,11 @@ var DEFAULT_RELAY_PORT = 8787, DEFAULT_REQUEST_TIMEOUT_MS = 30000, headersToObje
         url: url.pathname + url.search,
         ...bodyBytes && bodyBytes.length > 0 ? { bodyBase64: Buffer.from(bodyBytes).toString("base64") } : {}
       };
-      const responsePromise = new Promise((resolve14) => {
-        pending.set(id, resolve14);
+      const responsePromise = new Promise((resolve16) => {
+        pending.set(id, resolve16);
       });
       client.send(encodeTunnelMessage(message));
-      const timeout = new Promise((resolve14) => setTimeout(() => resolve14({ id, message: "timeout", type: "error" }), requestTimeoutMs));
+      const timeout = new Promise((resolve16) => setTimeout(() => resolve16({ id, message: "timeout", type: "error" }), requestTimeoutMs));
       const result = await Promise.race([responsePromise, timeout]);
       pending.delete(id);
       if (result.type === "error") {
@@ -177321,6 +178466,10 @@ if (command === "dev") {
   sendTelemetryEvent("cli:command", { command: "mem" });
   const { runMem: runMem2 } = await Promise.resolve().then(() => (init_mem(), exports_mem));
   await runMem2(args);
+} else if (command === "generate" || command === "g") {
+  sendTelemetryEvent("cli:command", { command: "generate" });
+  const { runGenerate: runGenerate2 } = await Promise.resolve().then(() => (init_generate(), exports_generate));
+  await runGenerate2(args);
 } else if (command === "env") {
   sendTelemetryEvent("cli:command", { command: "env" });
   const { runEnv: runEnv2 } = await Promise.resolve().then(() => (init_env(), exports_env));
@@ -177379,6 +178528,7 @@ if (command === "dev") {
   console.error("  doctor [--json] Diagnose the project (bun, config, framework dirs, env, port)");
   console.error("  env [--check] [--json] Report env vars the app reads (getEnv) and which are missing");
   console.error("  eslint        Run ESLint (cached)");
+  console.error("  generate <page|api|component> <name> [--framework <fw>] Scaffold a page, API plugin, or component");
   console.error("  info          Print system info for bug reports");
   console.error("  logs <name> [-f] [-n <lines>] Tail a running server's log by name");
   console.error("  ls [--sizes] [--budget <size>] [--json] List the project's pages by framework");